+[](https://app.codecov.io/github/rust-lang/rust-analyzer/tree/master)

+

+ match t.polarity {

+ ty::PredicatePolarity::Positive => write!(fmt, "{:?}", t.trait_ref),

+ ty::PredicatePolarity::Negative => write!(fmt, "!{:?}", t.trait_ref),

+ }

+ let prefix = match t.constness {

+ ty::BoundConstness::Const => "const",

+ ty::BoundConstness::Maybe => "[const]",

+ };

+ write!(fmt, "{prefix} {:?}", t.trait_ref)

+ write!(fmt, "NormalizesTo({} -> {:?})", t.alias, t.term)

+ write!(fmt, "{:?} <: {:?}", t.a, t.b)

+ write!(fmt, "CoercePredicate({:?} -> {:?})", t.a, t.b)

+ let tys = t.inputs_and_output.as_slice();

+ let (output, inputs) = tys.split_last().unwrap();

+ write!(fmt, "fn({:?}) -> {:?}", inputs, output)

+ match t {

+ ty::PatternKind::Range { start, end } => write!(fmt, "{:?}..={:?}", start, end),

+ ty::PatternKind::Or(list) => write!(fmt, "or({:?})", list),

+ ty::PatternKind::NotNull => fmt.write_str("!null"),

+ }

+ ("allows-misaligned-mem-access", &[]),

+ ast::BinExpr(it) => it.rhs()?,

+

+ check_assist(

+ add_braces,

+ r#"

+fn foo() {

+ let x;

+ x =$0 n + 100;

+}

+"#,

+ r#"

+fn foo() {

+ let x;

+ x = {

+ n + 100

+ };

+}

+"#,

+ );

+

+ check_assist(

+ add_braces,

+ r#"

+fn foo() {

+ if let x =$0 n + 100 {}

+}

+"#,

+ r#"

+fn foo() {

+ if let x = {

+ n + 100

+ } {}

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn suggest_add_braces_for_const_initializer() {

+ check_assist(

+ add_braces,

+ r#"

+const X: i32 =$0 1 + 2;

+"#,

+ r#"

+const X: i32 = {

+ 1 + 2

+};

+"#,

+ );

+ }

+

+ #[test]

+ fn suggest_add_braces_for_static_initializer() {

+ check_assist(

+ add_braces,

+ r#"

+static X: i32 $0= 1 + 2;

+"#,

+ r#"

+static X: i32 = {

+ 1 + 2

+};

+"#,

+ );

+ ast::{self, AstNode, HasLoopBody, syntax_factory::SyntaxFactory},

+ let loop_expr = ctx.find_node_at_offset::<ast::AnyHasLoopBody>()?;

+ let loop_kw = loop_token(&loop_expr)?;

+ if loop_expr.label().is_some() || !loop_kw.text_range().contains_inclusive(ctx.offset()) {

+ make.token(T![:]).into(),

+ make.whitespace(" ").into(),

+fn loop_token(loop_expr: &ast::AnyHasLoopBody) -> Option<syntax::SyntaxToken> {

+ loop_expr

+ .syntax()

+ .children_with_tokens()

+ .filter_map(|it| it.into_token())

+ .find(|it| matches!(it.kind(), T![for] | T![loop] | T![while]))

+}

+

+ let elements = vec![make.whitespace(" ").into(), label.syntax().clone().into()];

+ fn add_label_to_while_expr() {

+ check_assist(

+ add_label_to_loop,

+ r#"

+fn main() {

+ while$0 true {

+ break;

+ continue;

+ }

+}"#,

+ r#"

+fn main() {

+ ${1:'l}: while true {

+ break ${2:'l};

+ continue ${0:'l};

+ }

+}"#,

+ );

+ }

+

+ #[test]

+ fn add_label_to_for_expr() {

+ check_assist(

+ add_label_to_loop,

+ r#"

+fn main() {

+ for$0 _ in 0..5 {

+ break;

+ continue;

+ }

+}"#,

+ r#"

+fn main() {

+ ${1:'l}: for _ in 0..5 {

+ break ${2:'l};

+ continue ${0:'l};

+ }

+}"#,

+ );

+ }

+

+ #[test]

+

+ #[test]

+ fn do_not_add_label_if_outside_keyword() {

+ check_assist_not_applicable(

+ add_label_to_loop,

+ r#"

+fn main() {

+ 'l: loop {$0

+ break 'l;

+ continue 'l;

+ }

+}"#,

+ );

+

+ check_assist_not_applicable(

+ add_label_to_loop,

+ r#"

+fn main() {

+ 'l: while true {$0

+ break 'l;

+ continue 'l;

+ }

+}"#,

+ );

+ }

+use syntax::{

+ SyntaxKind, SyntaxNode, SyntaxToken,

+ ast::{self, AstNode, HasGenericParams, HasName},

+};

+ if ref_type_focused.lifetime().is_some_and(|lifetime| lifetime.text() != "'_") {

+ let changes = fetch_borrowed_types(&node)?;

+ acc.add(AssistId::quick_fix("add_lifetime_to_type"), "Add lifetime", target, |builder| {

+ for change in changes {

+ match change {

+ Change::Replace(it) => {

+ builder.replace(it.text_range(), "'a");

+ }

+ Change::Insert(it) => {

+ builder.insert(it.text_range().end(), "'a ");

+ }

+fn fetch_borrowed_types(node: &ast::Adt) -> Option<Vec<Change>> {

+ let ref_types: Vec<_> = match node {

+ find_ref_types_from_field_list(&record_field_list.into())?

+fn find_ref_types_from_field_list(field_list: &ast::FieldList) -> Option<Vec<Change>> {

+ let ref_types: Vec<_> = match field_list {

+ ast::FieldList::RecordFieldList(record_list) => {

+ record_list.fields().flat_map(|f| infer_lifetimes(f.syntax())).collect()

+ }

+ ast::FieldList::TupleFieldList(tuple_field_list) => {

+ tuple_field_list.fields().flat_map(|f| infer_lifetimes(f.syntax())).collect()

+ }

+enum Change {

+ Replace(SyntaxToken),

+ Insert(SyntaxToken),

+}

+

+fn infer_lifetimes(node: &SyntaxNode) -> Vec<Change> {

+ node.children()

+ .filter(|it| !matches!(it.kind(), SyntaxKind::FN_PTR_TYPE | SyntaxKind::TYPE_BOUND_LIST))

+ .flat_map(|it| {

+ infer_lifetimes(&it)

+ .into_iter()

+ .chain(ast::Lifetime::cast(it.clone()).and_then(|lt| {

+ lt.lifetime_ident_token().filter(|lt| lt.text() == "'_").map(Change::Replace)

+ }))

+ .chain(

+ ast::RefType::cast(it)

+ .filter(|ty| ty.lifetime().is_none())

+ .and_then(|ty| ty.amp_token())

+ .map(Change::Insert),

+ )

+ })

+ .collect()

+}

+

+ fn add_lifetime_to_nested_types() {

+ check_assist(

+ add_lifetime_to_type,

+ r#"struct Foo { a: &$0i32, b: &(&i32, fn(&str) -> &str) }"#,

+ r#"struct Foo<'a> { a: &'a i32, b: &'a (&'a i32, fn(&str) -> &str) }"#,

+ );

+ }

+

+ #[test]

+ fn add_lifetime_to_explicit_infer_lifetime() {

+ check_assist(

+ add_lifetime_to_type,

+ r#"struct Foo { a: &'_ $0i32, b: &'_ (&'_ i32, fn(&str) -> &str) }"#,

+ r#"struct Foo<'a> { a: &'a i32, b: &'a (&'a i32, fn(&str) -> &str) }"#,

+ );

+ }

+

+ #[test]

+ if arm.expr().is_none_or(is_empty_expr) {

+ let last_node = match last_arm.expr() {

+ Some(expr) => expr.syntax().clone(),

+ None => last_arm.syntax().clone(),

+ };

+ let last_node_range = ctx.sema.original_range_opt(&last_node)?.range;

+ if last_node_range.end() <= ctx.offset() && ctx.offset() < match_expr_range.end() {

+

+ if ast::Expr::cast(last_node.clone()).is_some_and(is_empty_expr)

+ && last_node_range.contains(ctx.offset())

+ && !last_node.text().contains_char('\n')

+ {

+ cov_mark::hit!(add_missing_match_arms_end_of_last_empty_arm);

+ return Some(());

+ }

+fn is_empty_expr(e: ast::Expr) -> bool {

+ match e {

+ ast::Expr::BlockExpr(b) => b.statements().next().is_none() && b.tail_expr().is_none(),

+ ast::Expr::TupleExpr(t) => t.fields().next().is_none(),

+ _ => false,

+ }

+}

+

+ cov_mark::check_count!(add_missing_match_arms_end_of_last_arm, 2);

+

+ check_assist(

+ add_missing_match_arms,

+ r#"

+enum A { One, Two }

+enum B { One, Two }

+

+fn main() {

+ let a = A::One;

+ let b = B::One;

+ match (a, b) {

+ (A::Two, B::One) => 2$0,

+ }

+}

+"#,

+ r#"

+enum A { One, Two }

+enum B { One, Two }

+

+fn main() {

+ let a = A::One;

+ let b = B::One;

+ match (a, b) {

+ (A::Two, B::One) => 2,

+ (A::One, B::One) => ${1:todo!()},

+ (A::One, B::Two) => ${2:todo!()},

+ (A::Two, B::Two) => ${3:todo!()},$0

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn add_missing_match_arms_end_of_last_empty_arm() {

+ cov_mark::check_count!(add_missing_match_arms_end_of_last_empty_arm, 2);

+ check_assist(

+ add_missing_match_arms,

+ r#"

+enum A { One, Two }

+enum B { One, Two }

+

+fn main() {

+ let a = A::One;

+ let b = B::One;

+ match (a, b) {

+ (A::Two, B::One) => {$0}

+ }

+}

+"#,

+ r#"

+enum A { One, Two }

+enum B { One, Two }

+

+fn main() {

+ let a = A::One;

+ let b = B::One;

+ match (a, b) {

+ (A::Two, B::One) => {}

+ (A::One, B::One) => ${1:todo!()},

+ (A::One, B::Two) => ${2:todo!()},

+ (A::Two, B::Two) => ${3:todo!()},$0

+ }

+}

+"#,

+ );

+

+ check_assist(

+ add_missing_match_arms,

+ r#"

+enum A { One, Two }

+enum B { One, Two }

+

+fn main() {

+ let a = A::One;

+ let b = B::One;

+ match (a, b) {

+ (A::Two, B::One) => ($0)

+ }

+}

+"#,

+ r#"

+enum A { One, Two }

+enum B { One, Two }

+

+fn main() {

+ let a = A::One;

+ let b = B::One;

+ match (a, b) {

+ (A::Two, B::One) => (),

+ (A::One, B::One) => ${1:todo!()},

+ (A::One, B::Two) => ${2:todo!()},

+ (A::Two, B::Two) => ${3:todo!()},$0

+ }

+}

+"#,

+ );

+ let closure_body = closure_expr.body()?;

+ make.item_enum(

+ make::block_expr([], Some(body.reset_indent().indent(1.into())))

+ check_assist(

+ convert_closure_to_fn,

+ r#"

+//- minicore: copy

+fn foo() {

+ {

+ let closure = |$0| match () {

+ () => {},

+ };

+ closure();

+ }

+}

+"#,

+ r#"

+fn foo() {

+ {

+ fn closure() {

+ match () {

+ () => {},

+ }

+ }

+ closure();

+ }

+}

+"#,

+ );

+ ast::{self, HasAttrs, HasLoopBody, edit::IndentLevel, syntax_factory::SyntaxFactory},

+ (make.expr_paren(iterable).into(), Some(make.name_ref("into_iter")))

+ make.expr_method_call(iterable, method, make.arg_list([])).into()

+ &make,

+ make.whitespace(format!("\n{indent}").as_str()),

+ let opt_pat = make.tuple_struct_pat(make.ident_path("Some"), [pat]);

+ make.expr_path(make.ident_path(&tmp_var)),

+use syntax::ast::{self, AstNode, HasGenericArgs, HasName, syntax_factory::SyntaxFactory};

+ let make = SyntaxFactory::with_mappings();

+

+ editor.replace(trait_ty.syntax(), make.ty(&format!("TryFrom<{from_type}>")).syntax());

+ make.ty("Result<Self, Self::Error>").syntax(),

+ editor.replace(from_fn_name.syntax(), make.name("try_from").syntax());

+ editor.replace(tail_expr.syntax(), wrap_ok(&make, tail_expr.clone()).syntax());

+ let t = r.expr().unwrap_or_else(|| make.expr_unit());

+ editor.replace(t.syntax(), wrap_ok(&make, t.clone()).syntax());

+ let error_type_alias =

+ make.ty_alias(None, "Error", None, None, None, Some((make.ty("()"), None)));

+ let error_type = ast::AssocItem::TypeAlias(error_type_alias);

+ make.whitespace(&format!("\n{indent}")).syntax_element(),

+ make.whitespace("\n").syntax_element(),

+ editor.add_mappings(make.finish_with_mappings());

+fn wrap_ok(make: &SyntaxFactory, expr: ast::Expr) -> ast::Expr {

+ make.expr_call(make.expr_path(make.path_from_text("Ok")), make.arg_list([expr])).into()

+ NodeOrToken, SyntaxKind, SyntaxNode, T,

+ algo::next_non_trivia_token,

+ ast::{

+ self, AstNode, HasAttrs, HasGenericParams, HasVisibility, syntax_factory::SyntaxFactory,

+ },

+ syntax_editor::{Element, Position, SyntaxEditor},

+use crate::{

+ AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder, utils::cover_edit_range,

+};

+ |builder| {

+ edit_field_references(ctx, builder, record_fields.fields());

+ edit_struct_references(ctx, builder, strukt_def);

+ edit_struct_def(ctx, builder, &strukt_or_variant, record_fields);

+ builder: &mut SourceChangeBuilder,

+ let make = SyntaxFactory::without_mappings();

+ let mut edit = builder.make_editor(strukt.syntax());

+

+ let tuple_fields = make.tuple_field_list(tuple_fields);

+ let mut elements = vec![tuple_fields.syntax().clone().into()];

+ edit.delete(w.syntax());

+ elements.extend([

+ make.whitespace("\n").into(),

+ remove_trailing_comma(w).into(),

+ make.token(T![;]).into(),

+ make.whitespace("\n").into(),

+ ]);

+ edit.delete(tok);

+ elements.push(make.token(T![;]).into());

+ edit.replace_with_many(record_fields.syntax(), elements);

+ edit.delete(tok)

+

+ builder.add_file_edits(ctx.vfs_file_id(), edit);

+ builder: &mut SourceChangeBuilder,

+ let source = ctx.sema.parse(file_id);

+ let mut edit = builder.make_editor(source.syntax());

+ process_struct_name_reference(ctx, r, &mut edit, &source);

+ builder.add_file_edits(file_id.file_id(ctx.db()), edit);

+ edit: &mut SyntaxEditor,

+ source: &ast::SourceFile,

+ // When we failed to get the original range for the whole struct pattern node,

+ record_to_tuple_struct_like(

+ ctx,

+ source,

+ edit,

+ record_struct_pat.record_pat_field_list()?,

+ |it| it.fields().filter_map(|it| it.name_ref()),

+ // When we failed to get the original range for the whole struct expression node,

+ record_to_tuple_struct_like(

+ ctx,

+ source,

+ edit,

+ record_expr.record_expr_field_list()?,

+ |it| it.fields().filter_map(|it| it.name_ref()),

+ );

+fn record_to_tuple_struct_like<T, I>(

+ ctx: &AssistContext<'_>,

+ source: &ast::SourceFile,

+ edit: &mut SyntaxEditor,

+ field_list: T,

+ fields: impl FnOnce(&T) -> I,

+) -> Option<()>

+where

+ T: AstNode,

+ I: IntoIterator<Item = ast::NameRef>,

+{

+ let make = SyntaxFactory::without_mappings();

+ let orig = ctx.sema.original_range_opt(field_list.syntax())?;

+ let list_range = cover_edit_range(source, orig.range);

+

+ let l_curly = match list_range.start() {

+ NodeOrToken::Node(node) => node.first_token()?,

+ NodeOrToken::Token(t) => t.clone(),

+ };

+ let r_curly = match list_range.end() {

+ NodeOrToken::Node(node) => node.last_token()?,

+ NodeOrToken::Token(t) => t.clone(),

+ };

+

+ if l_curly.kind() == T!['{'] {

+ delete_whitespace(edit, l_curly.prev_token());

+ delete_whitespace(edit, l_curly.next_token());

+ edit.replace(l_curly, make.token(T!['(']));

+ }

+ if r_curly.kind() == T!['}'] {

+ delete_whitespace(edit, r_curly.prev_token());

+ edit.replace(r_curly, make.token(T![')']));

+ }

+

+ for name_ref in fields(&field_list) {

+ let Some(orig) = ctx.sema.original_range_opt(name_ref.syntax()) else { continue };

+ let name_range = cover_edit_range(source, orig.range);

+

+ if let Some(colon) = next_non_trivia_token(name_range.end().clone())

+ && colon.kind() == T![:]

+ {

+ edit.delete(&colon);

+ edit.delete_all(name_range);

+

+ if let Some(next) = next_non_trivia_token(colon.clone())

+ && next.kind() != T!['}']

+ {

+ // Avoid overlapping delete whitespace on `{ field: }`

+ delete_whitespace(edit, colon.next_token());

+ }

+ }

+ }

+ Some(())

+}

+

+ builder: &mut SourceChangeBuilder,

+ let make = SyntaxFactory::without_mappings();

+ let source = ctx.sema.parse(file_id);

+ let mut edit = builder.make_editor(source.syntax());

+

+ edit.replace_all(

+ cover_edit_range(&source, r.range),

+ vec![make.name_ref(&index.to_string()).syntax().clone().into()],

+ );

+

+ builder.add_file_edits(file_id.file_id(ctx.db()), edit);

+fn delete_whitespace(edit: &mut SyntaxEditor, whitespace: Option<impl Element>) {

+ let Some(whitespace) = whitespace else { return };

+ let NodeOrToken::Token(token) = whitespace.syntax_element() else { return };

+

+ if token.kind() == SyntaxKind::WHITESPACE && !token.text().contains('\n') {

+ edit.delete(token);

+ }

+}

+

+fn remove_trailing_comma(w: ast::WhereClause) -> SyntaxNode {

+ let w = w.syntax().clone_subtree();

+ let mut editor = SyntaxEditor::new(w.clone());

+ if let Some(last) = w.last_child_or_token()

+ && last.kind() == T![,]

+ {

+ editor.delete(last);

+ }

+ editor.finish().new_root().clone()

+}

+

+ fn convert_constructor_expr_uses_self() {

+ // regression test for #21595

+ check_assist(

+ convert_named_struct_to_tuple_struct,

+ r#"

+struct $0Foo { field1: u32 }

+impl Foo {

+ fn clone(&self) -> Self {

+ Self { field1: self.field1 }

+ }

+}"#,

+ r#"

+struct Foo(u32);

+impl Foo {

+ fn clone(&self) -> Self {

+ Self(self.0)

+ }

+}"#,

+ );

+

+ check_assist(

+ convert_named_struct_to_tuple_struct,

+ r#"

+macro_rules! id {

+ ($($t:tt)*) => { $($t)* }

+}

+struct $0Foo { field1: u32 }

+impl Foo {

+ fn clone(&self) -> Self {

+ id!(Self { field1: self.field1 })

+ }

+}"#,

+ r#"

+macro_rules! id {

+ ($($t:tt)*) => { $($t)* }

+}

+struct Foo(u32);

+impl Foo {

+ fn clone(&self) -> Self {

+ id!(Self(self.0))

+ }

+}"#,

+ );

+ }

+

+ #[test]

+ fn convert_pat_uses_self() {

+ // regression test for #21595

+ check_assist(

+ convert_named_struct_to_tuple_struct,

+ r#"

+enum Foo {

+ $0Value { field: &'static Foo },

+ Nil,

+}

+fn foo(foo: &Foo) {

+ if let Foo::Value { field: Foo::Value { field } } = foo {}

+}"#,

+ r#"

+enum Foo {

+ Value(&'static Foo),

+ Nil,

+}

+fn foo(foo: &Foo) {

+ if let Foo::Value(Foo::Value(field)) = foo {}

+}"#,

+ );

+

+ check_assist(

+ convert_named_struct_to_tuple_struct,

+ r#"

+macro_rules! id {

+ ($($t:tt)*) => { $($t)* }

+}

+enum Foo {

+ $0Value { field: &'static Foo },

+ Nil,

+}

+fn foo(foo: &Foo) {

+ if let id!(Foo::Value { field: Foo::Value { field } }) = foo {}

+}"#,

+ r#"

+macro_rules! id {

+ ($($t:tt)*) => { $($t)* }

+}

+enum Foo {

+ Value(&'static Foo),

+ Nil,

+}

+fn foo(foo: &Foo) {

+ if let id!(Foo::Value(Foo::Value(field))) = foo {}

+}"#,

+ );

+ }

+

+ #[test]

+ let s = Struct(

+ 42,

+ );

+ syntax_factory::SyntaxFactory,

+ utils::{invert_boolean_expression, is_never_block},

+ let make = SyntaxFactory::without_mappings();

+ let let_chains = flat_let_chain(cond, &make);

+ early_expression(parent_container, &ctx.sema, &make)

+ .map(ast::make::tail_only_block_expr)

+ let make = SyntaxFactory::without_mappings();

+ make.let_else_stmt(pat, None, expr, early_expression.clone());

+ let then_branch = clean_stmt_block(&early_expression, &make);

+ let cond = invert_boolean_expression(&make, expr);

+ make.expr_if(cond, then_branch, None).indent(if_indent_level)

+ .then(|| make.whitespace(newline).into())

+ let make = SyntaxFactory::without_mappings();

+ early_expression(parent_container, &ctx.sema, &make)?

+ let make = SyntaxFactory::without_mappings();

+ let let_else_stmt = make.let_else_stmt(

+ editor.add_mappings(make.finish_with_mappings());

+ make: &SyntaxFactory,

+ let none_expr = make.expr_path(make.ident_path("None"));

+ make.expr_return(Some(none_expr))

+ return Some(return_none_expr().into());

+ return Some(return_none_expr().into());

+ WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make.expr_continue(None).into(),

+ FN | CLOSURE_EXPR => make.expr_return(None).into(),

+fn flat_let_chain(mut expr: ast::Expr, make: &SyntaxFactory) -> Vec<ast::Expr> {

+ chains.push(make.expr_bin_op(rhs, ast::BinaryOp::LogicOp(ast::LogicOp::And), last));

+fn clean_stmt_block(block: &ast::BlockExpr, make: &SyntaxFactory) -> ast::BlockExpr {

+ make.block_expr(once(make.expr_stmt(tail_expr).into()), None)

+use ide_db::{

+ defs::{Definition, NameRefClass},

+ search::FileReference,

+};

+ SyntaxKind, T,

+ self, AstNode, HasArgList, HasAttrs, HasGenericParams, HasVisibility,

+ syntax_factory::SyntaxFactory,

+use crate::{

+ AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder, utils::cover_edit_range,

+};

+ for (file_id, refs) in usages {

+ let source = ctx.sema.parse(file_id);

+ let mut editor = edit.make_editor(source.syntax());

+ for r in refs {

+ process_struct_name_reference(ctx, r, &mut editor, &source, &strukt_def, names);

+ edit.add_file_edits(file_id.file_id(ctx.db()), editor);

+ }

+}

+

+fn process_struct_name_reference(

+ ctx: &AssistContext<'_>,

+ r: FileReference,

+ editor: &mut SyntaxEditor,

+ source: &ast::SourceFile,

+ strukt_def: &Definition,

+ names: &[ast::Name],

+) -> Option<()> {

+ let make = SyntaxFactory::without_mappings();

+ let name_ref = r.name.as_name_ref()?;

+ let path_segment = name_ref.syntax().parent().and_then(ast::PathSegment::cast)?;

+ let full_path = path_segment.syntax().parent().and_then(ast::Path::cast)?.top_path();

+

+ if full_path.segment()?.name_ref()? != *name_ref {

+ // `name_ref` isn't the last segment of the path, so `full_path` doesn't point to the

+ // struct we want to edit.

+ return None;

+ }

+

+ let parent = full_path.syntax().parent()?;

+ match_ast! {

+ match parent {

+ ast::TupleStructPat(tuple_struct_pat) => {

+ let range = ctx.sema.original_range_opt(tuple_struct_pat.syntax())?.range;

+ let new = make.record_pat_with_fields(

+ full_path,

+ generate_record_pat_list(&tuple_struct_pat, names),

+ );

+ editor.replace_all(cover_edit_range(source, range), vec![new.syntax().clone().into()]);

+ },

+ ast::PathExpr(path_expr) => {

+ let call_expr = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;

+

+ // this also includes method calls like Foo::new(42), we should skip them

+ match NameRefClass::classify(&ctx.sema, name_ref) {

+ Some(NameRefClass::Definition(Definition::SelfType(_), _)) => {},

+ Some(NameRefClass::Definition(def, _)) if def == *strukt_def => {},

+ _ => return None,

+ }

+

+ let arg_list = call_expr.arg_list()?;

+ let mut first_insert = vec![];

+ for (expr, name) in arg_list.args().zip(names) {

+ let range = ctx.sema.original_range_opt(expr.syntax())?.range;

+ let place = cover_edit_range(source, range);

+ let elements = vec![

+ make.name_ref(&name.text()).syntax().clone().into(),

+ make.token(T![:]).into(),

+ make.whitespace(" ").into(),

+ ];

+ if first_insert.is_empty() {

+ // XXX: SyntaxEditor cannot insert after deleted element

+ first_insert = elements;

+ } else {

+ editor.insert_all(Position::before(place.start()), elements);

+ process_delimiter(ctx, source, editor, &arg_list, first_insert);

+ },

+ _ => {}

+ }

+ Some(())

+}

+

+fn process_delimiter(

+ ctx: &AssistContext<'_>,

+ source: &ast::SourceFile,

+ editor: &mut SyntaxEditor,

+ list: &impl AstNode,

+ first_insert: Vec<syntax::SyntaxElement>,

+) {

+ let Some(range) = ctx.sema.original_range_opt(list.syntax()) else { return };

+ let place = cover_edit_range(source, range.range);

+

+ let l_paren = match place.start() {

+ syntax::NodeOrToken::Node(node) => node.first_token(),

+ syntax::NodeOrToken::Token(t) => Some(t.clone()),

+ };

+ let r_paren = match place.end() {

+ syntax::NodeOrToken::Node(node) => node.last_token(),

+ syntax::NodeOrToken::Token(t) => Some(t.clone()),

+ };

+

+ let make = SyntaxFactory::without_mappings();

+ if let Some(l_paren) = l_paren

+ && l_paren.kind() == T!['(']

+ {

+ let mut open_delim = vec![

+ make.whitespace(" ").into(),

+ make.token(T!['{']).into(),

+ make.whitespace(" ").into(),

+ ];

+ open_delim.extend(first_insert);

+ editor.replace_with_many(l_paren, open_delim);

+ }

+ if let Some(r_paren) = r_paren

+ && r_paren.kind() == T![')']

+ {

+ editor.replace_with_many(

+ r_paren,

+ vec![make.whitespace(" ").into(), make.token(T!['}']).into()],

+ );

+ let mut editor = edit.make_editor(source.syntax());

+ && let Some(original) = ctx.sema.original_range_opt(name_ref.syntax())

+ editor.replace_all(

+ cover_edit_range(&source, original.range),

+ vec![name.syntax().clone().into()],

+ );

+

+ #[test]

+ fn convert_expr_uses_self() {

+ check_assist(

+ convert_tuple_struct_to_named_struct,

+ r#"

+macro_rules! id {

+ ($($t:tt)*) => { $($t)* }

+}

+struct T$0(u8);

+fn test(t: T) {

+ T(t.0);

+ id!(T(t.0));

+}"#,

+ r#"

+macro_rules! id {

+ ($($t:tt)*) => { $($t)* }

+}

+struct T { field1: u8 }

+fn test(t: T) {

+ T { field1: t.field1 };

+ id!(T { field1: t.field1 });

+}"#,

+ );

+ }

+

+ #[test]

+ #[ignore = "FIXME overlap edits in nested uses self"]

+ fn convert_pat_uses_self() {

+ check_assist(

+ convert_tuple_struct_to_named_struct,

+ r#"

+macro_rules! id {

+ ($($t:tt)*) => { $($t)* }

+}

+enum T {

+ $0Value(&'static T),

+ Nil,

+}

+fn test(t: T) {

+ if let T::Value(T::Value(t)) = t {}

+ if let id!(T::Value(T::Value(t))) = t {}

+}"#,

+ r#"

+macro_rules! id {

+ ($($t:tt)*) => { $($t)* }

+}

+enum T {

+ Value { field1: &'static T },

+ Nil,

+}

+fn test(t: T) {

+ if let T::Value { field1: T::Value { field1: t } } = t {}

+ if let id!(T::Value { field1: T::Value { field1: t } }) = t {}

+}"#,

+ );

+ }

+

+ syntax_factory::SyntaxFactory,

+ utils::invert_boolean_expression,

+ let make = SyntaxFactory::without_mappings();

+ let break_block = make

+ .block_expr(

+ iter::once(make.expr_stmt(make.expr_break(None, None).into()).into()),

+ None,

+ )

+ .indent(IndentLevel(1));

+ vec![make.token(T![loop]).syntax_element()],

+ let if_expr = make.expr_if(while_cond, then_branch, Some(break_block.into()));

+ let stmts = iter::once(make.expr_stmt(if_expr.into()).into());

+ let block_expr = make.block_expr(stmts, None);

+ let if_cond = invert_boolean_expression(&make, while_cond);

+ let if_expr = make.expr_if(if_cond, break_block, None).indent(while_indent_level);

+ make.whitespace(&format!("\n{while_indent_level}")),

+ make.whitespace(&format!("\n{}", while_indent_level + 1)).into(),

+ edit.add_mappings(make.finish_with_mappings());

+ let new_expr = make.expr_path(make.ident_path(new_field_name));

+ (replace_expr.syntax().clone(), ref_data.wrap_expr(new_expr, make).syntax().clone())

+ (field_expr.syntax().clone(), new_expr.syntax().clone())

+ make.ident_path("todo"),

+ |builder| {

+ let make = SyntaxFactory::with_mappings();

+ let mut editor = builder.make_editor(try_expr.syntax());

+

+ TryEnum::Option => make.path_pat(make.ident_path("None")),

+ TryEnum::Result => make

+ .tuple_struct_pat(

+ make.ident_path("Err"),

+ iter::once(make.path_pat(make.ident_path("err"))),

+ )

+ .into(),

+ TryEnum::Option => make.expr_return(Some(make.expr_path(make.ident_path("None")))),

+ TryEnum::Result => make.expr_return(Some(

+ make.expr_call(

+ make.expr_path(make.ident_path("Err")),

+ make.arg_list(iter::once(make.expr_path(make.ident_path("err")))),

+ let happy_arm = make.match_arm(

+ try_enum.happy_pattern(make.ident_pat(false, false, make.name("it")).into()),

+ make.expr_path(make.ident_path("it")),

+ let sad_arm = make.match_arm(sad_pat, None, sad_expr.into());

+ let match_arm_list = make.match_arm_list([happy_arm, sad_arm]);

+ let expr_match = make

+ .expr_match(expr.clone(), match_arm_list)

+ editor.replace(try_expr.syntax(), expr_match.syntax());

+ editor.add_mappings(make.finish_with_mappings());

+ builder.add_file_edits(ctx.vfs_file_id(), editor);

+ ast::{self, TokenTree, syntax_factory::SyntaxFactory},

+ let make = SyntaxFactory::without_mappings();

+ new_tt_bits.push(NodeOrToken::Token(make.expr_literal(&new_fmt).token().clone()));

+ NodeOrToken::Token(make.token(T![,])),

+ NodeOrToken::Token(make.whitespace(" ")),

+ let mut expr_tt = utils::tt_from_syntax(expr, &make);

+ new_tt_bits.push(NodeOrToken::Token(make.token(T![_])));

+ expr.syntax().ancestors().find_map(valid_target_expr(ctx))?.syntax().clone()

+ .find_map(valid_target_expr(ctx))?;

+ let name_expr = make.expr_path(make.ident_path(&var_name));

+ make.whitespace(&trailing_ws).into(),

+fn valid_target_expr(ctx: &AssistContext<'_>) -> impl Fn(SyntaxNode) -> Option<ast::Expr> {

+ |node| match node.kind() {

+ SyntaxKind::LOOP_EXPR | SyntaxKind::LET_EXPR => None,

+ SyntaxKind::PATH_EXPR => {

+ let path_expr = ast::PathExpr::cast(node)?;

+ let path_resolution = ctx.sema.resolve_path(&path_expr.path()?)?;

+ like_const_value(ctx, path_resolution).then_some(path_expr.into())

+ }

+fn like_const_value(ctx: &AssistContext<'_>, path_resolution: hir::PathResolution) -> bool {

+ let db = ctx.db();

+ let adt_like_const_value = |adt: Option<hir::Adt>| matches!(adt, Some(hir::Adt::Struct(s)) if s.kind(db) == hir::StructKind::Unit);

+ match path_resolution {

+ hir::PathResolution::Def(def) => match def {

+ hir::ModuleDef::Adt(adt) => adt_like_const_value(Some(adt)),

+ hir::ModuleDef::Variant(variant) => variant.kind(db) == hir::StructKind::Unit,

+ hir::ModuleDef::TypeAlias(ty) => adt_like_const_value(ty.ty(db).as_adt()),

+ hir::ModuleDef::Const(_) | hir::ModuleDef::Static(_) => true,

+ hir::ModuleDef::Trait(_)

+ | hir::ModuleDef::BuiltinType(_)

+ | hir::ModuleDef::Macro(_)

+ | hir::ModuleDef::Module(_) => false,

+ hir::ModuleDef::Function(_) => false, // no extract named function

+ },

+ hir::PathResolution::SelfType(ty) => adt_like_const_value(ty.self_ty(db).as_adt()),

+ hir::PathResolution::ConstParam(_) => true,

+ hir::PathResolution::Local(_)

+ | hir::PathResolution::TypeParam(_)

+ | hir::PathResolution::BuiltinAttr(_)

+ | hir::PathResolution::ToolModule(_)

+ | hir::PathResolution::DeriveHelper(_) => false,

+ }

+}

+

+ fn extract_non_local_path_expr() {

+ check_assist_by_label(

+ extract_variable,

+ r#"

+struct Foo;

+fn foo() -> Foo {

+ $0Foo$0

+}

+"#,

+ r#"

+struct Foo;

+fn foo() -> Foo {

+ let $0foo = Foo;

+ foo

+}

+"#,

+ "Extract into variable",

+ );

+ }

+

+ #[test]

+ syntax_factory::SyntaxFactory,

+ let make = SyntaxFactory::without_mappings();

+ let field = make

+ .field_from_idents(["self", &field_name])

+ .expect("always be a valid expression");

+ let v = source.value;

+ let fn_name = make.name(&name);

+ method_source.param_list().unwrap_or_else(|| make.param_list(None, []));

+ .map(|v| convert_param_list_to_arg_list(v, &make))

+ .unwrap_or_else(|| make.arg_list([]));

+ let tail_expr = make.expr_method_call(field, make.name_ref(&name), arg_list).into();

+ if is_async { make.expr_await(tail_expr).into() } else { tail_expr };

+ let body = make.block_expr([], Some(tail_expr_finished));

+ let f = make

+ .fn_(

+ None,

+ vis,

+ fn_name,

+ type_params,

+ where_clause,

+ params,

+ body,

+ ret_type,

+ is_async,

+ is_const,

+ is_unsafe,

+ is_gen,

+ )

+ .indent(IndentLevel(1));

+ let assoc_item_list = make.assoc_item_list(vec![item]);

+ let assoc_item_list = make.assoc_item_list(vec![item]);

+ let impl_def = make.impl_(

+ syntax::ast::Type::PathType(make.ty_path(make.ident_path(name))),

+ );

+ make.whitespace(&format!("\n\n{indent}")).into(),

+ editor.add_mappings(make.finish_with_mappings());

+ let other_args = convert_param_list_to_arg_list(l, &make);

+ .expr_call(make.expr_path(qualified_path), convert_param_list_to_arg_list(l, &make))

+ convert_param_list_to_arg_list(make.param_list(None, Vec::new()), &make),

+ AstNode, AstToken, SyntaxKind, T,

+ ast::{

+ self, HasDocComments, HasGenericParams, HasName, HasVisibility, edit::AstNodeEdit, make,

+ },

+// trait ${0:Create}<const N: usize> {

+// impl<const N: usize> ${0:Create}<N> for Foo<N> {

+ &trait_name(&impl_assoc_items).text(),

+ remove_doc_comments(&mut editor, &item);

+fn trait_name(items: &ast::AssocItemList) -> ast::Name {

+ let mut fn_names = items

+ .assoc_items()

+ .filter_map(|x| if let ast::AssocItem::Fn(f) = x { f.name() } else { None });

+ fn_names

+ .next()

+ .and_then(|name| {

+ fn_names.next().is_none().then(|| make::name(&stdx::to_camel_case(&name.text())))

+ })

+ .unwrap_or_else(|| make::name("NewTrait"))

+}

+

+fn remove_doc_comments(editor: &mut SyntaxEditor, item: &ast::AssocItem) {

+ for doc in item.doc_comments() {

+ if let Some(next) = doc.syntax().next_token()

+ && next.kind() == SyntaxKind::WHITESPACE

+ {

+ editor.delete(next);

+ }

+ editor.delete(doc.syntax());

+ }

+}

+

+trait Add {

+impl Add for Foo {

+ fn add(&mut self, x: f64) {

+ self.0 += x;

+ }

+}"#,

+ )

+ }

+

+ #[test]

+ fn test_remove_doc_comments() {

+ check_assist_no_snippet_cap(

+ generate_trait_from_impl,

+ r#"

+struct Foo(f64);

+

+impl F$0oo {

+ /// Add `x`

+ ///

+ /// # Examples

+ #[cfg(true)]

+ fn add(&mut self, x: f64) {

+ self.0 += x;

+ }

+}"#,

+ r#"

+struct Foo(f64);

+

+trait Add {

+ /// Add `x`

+ ///

+ /// # Examples

+ #[cfg(true)]

+ fn add(&mut self, x: f64);

+}

+

+impl Add for Foo {

+ #[cfg(true)]

+trait AFunc {

+impl AFunc for Foo {

+ trait Foo {

+ impl Foo for S {

+ fn test_multi_fn_impl_not_suggest_trait_name() {

+ check_assist_no_snippet_cap(

+ generate_trait_from_impl,

+ r#"

+impl S$0 {

+ fn foo() {}

+ fn bar() {}

+}"#,

+ r#"

+trait NewTrait {

+ fn foo();

+ fn bar();

+}

+

+impl NewTrait for S {

+ fn foo() {}

+ fn bar() {}

+}"#,

+ )

+ }

+

+ #[test]

+use either::{Either, for_both};

+ Direction, TextRange,

+ syntax_editor::{Element, SyntaxEditor},

+ } else if let Some(let_stmt) = ctx.find_node_at_offset() {

+ let initializer_expr = match &let_stmt {

+ either::Either::Left(it) => it.initializer()?,

+ either::Either::Right(it) => it.expr()?,

+ };

+

+ if let Some(bin_expr) = let_stmt.syntax().parent().and_then(ast::BinExpr::cast)

+ && let Some(op_token) = bin_expr.op_token()

+ editor.delete(&op_token);

+ remove_whitespace(op_token, Direction::Prev, &mut editor);

+ remove_whitespace(let_stmt.syntax(), Direction::Prev, &mut editor);

+ } else {

+ remove_whitespace(let_stmt.syntax(), Direction::Next, &mut editor);

+ let_stmt: Either<ast::LetStmt, ast::LetExpr>,

+ let_stmt: Either<ast::LetStmt, ast::LetExpr>,

+ let bind_pat = match for_both!(&let_stmt, it => it.pat())? {

+ let let_stmt = AstNode::cast(bind_pat.syntax().parent()?)?;

+fn remove_whitespace(elem: impl Element, dir: Direction, editor: &mut SyntaxEditor) {

+ let token = match elem.syntax_element() {

+ syntax::NodeOrToken::Node(node) => match dir {

+ Direction::Next => node.last_token(),

+ Direction::Prev => node.first_token(),

+ },

+ syntax::NodeOrToken::Token(t) => Some(t),

+ };

+ let next_token = match dir {

+ Direction::Next => token.and_then(|it| it.next_token()),

+ Direction::Prev => token.and_then(|it| it.prev_token()),

+ };

+ if let Some(whitespace) = next_token.and_then(ast::Whitespace::cast) {

+ editor.delete(whitespace.syntax());

+ }

+}

+

+ fn test_inline_let_expr() {

+ check_assist(

+ inline_local_variable,

+ r"

+fn bar(a: usize) {}

+fn foo() {

+ if let a$0 = 1

+ && true

+ {

+ a + 1;

+ if a > 10 {}

+ while a > 10 {}

+ let b = a * 10;

+ bar(a);

+ }

+}",

+ r"

+fn bar(a: usize) {}

+fn foo() {

+ if true

+ {

+ 1 + 1;

+ if 1 > 10 {}

+ while 1 > 10 {}

+ let b = 1 * 10;

+ bar(1);

+ }

+}",

+ );

+ }

+

+ #[test]

+ fn let_expr_works_on_local_usage() {

+ check_assist(

+ inline_local_variable,

+ r#"

+fn f() {

+ if let xyz = 0

+ && true

+ {

+ xyz$0;

+ }

+}

+"#,

+ r#"

+fn f() {

+ if true

+ {

+ 0;

+ }

+}

+"#,

+ );

+

+ check_assist(

+ inline_local_variable,

+ r#"

+fn f() {

+ if let xyz = true

+ && xyz$0

+ {

+ }

+}

+"#,

+ r#"

+fn f() {

+ if true

+ {

+ }

+}

+"#,

+ );

+

+ check_assist(

+ inline_local_variable,

+ r#"

+fn f() {

+ if true

+ && let xyz = 0

+ {

+ xyz$0;

+ }

+}

+"#,

+ r#"

+fn f() {

+ if true

+ {

+ 0;

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ AstNode, NodeOrToken, SyntaxKind, SyntaxNode, T,

+ // Check if this lifetime is inside a LifetimeArg (in angle brackets)

+ if let Some(lifetime_arg) =

+ old_lifetime.syntax().parent().and_then(ast::LifetimeArg::cast)

+ {

+ // Remove LifetimeArg and associated comma/whitespace

+ let lifetime_arg_syntax = lifetime_arg.syntax();

+ removals.push(NodeOrToken::Node(lifetime_arg_syntax.clone()));

+

+ // Remove comma and whitespace (look forward then backward)

+ let comma_and_ws: Vec<_> = lifetime_arg_syntax

+ .siblings_with_tokens(syntax::Direction::Next)

+ .skip(1)

+ .take_while(|it| it.as_token().is_some())

+ .take_while_inclusive(|it| it.kind() == T![,])

+ .collect();

+

+ if comma_and_ws.iter().any(|it| it.kind() == T![,]) {

+ removals.extend(comma_and_ws);

+ } else {

+ // No comma after, try before

+ let comma_and_ws: Vec<_> = lifetime_arg_syntax

+ .siblings_with_tokens(syntax::Direction::Prev)

+ .skip(1)

+ .take_while(|it| it.as_token().is_some())

+ .take_while_inclusive(|it| it.kind() == T![,])

+ .collect();

+ removals.extend(comma_and_ws);

+ }

+ continue;

+ }

+ if let Some(ws) = syntax.next_sibling_or_token()

+ && ws.kind() == SyntaxKind::WHITESPACE

+ {

+ removals.push(ws);

+ // Deduplicate removals to avoid intersecting changes

+ removals.sort_by_key(|n| n.text_range().start());

+ removals.dedup();

+

+ // Remove GenericArgList entirely if all its args are being removed (avoids empty angle brackets)

+ let generic_arg_lists_to_check: Vec<_> =

+ updated_concrete_type.descendants().filter_map(ast::GenericArgList::cast).collect();

+

+ for generic_arg_list in generic_arg_lists_to_check {

+ let will_be_empty = generic_arg_list.generic_args().all(|arg| match arg {

+ ast::GenericArg::LifetimeArg(lt_arg) => removals.iter().any(|removal| {

+ if let NodeOrToken::Node(node) = removal { node == lt_arg.syntax() } else { false }

+ }),

+ _ => false,

+ });

+

+ if will_be_empty && generic_arg_list.generic_args().next().is_some() {

+ removals.retain(|removal| {

+ if let NodeOrToken::Node(node) = removal {

+ !node.ancestors().any(|anc| anc == *generic_arg_list.syntax())

+ } else {

+ true

+ }

+ });

+ removals.push(NodeOrToken::Node(generic_arg_list.syntax().clone()));

+ }

+ }

+

+ #[test]

+ fn inline_types_with_lifetime() {

+ check_assist(

+ inline_type_alias_uses,

+ r#"

+struct A<'a, 'b>(pub &'a mut &'b mut ());

+

+type $0T<'a, 'b> = A<'a, 'b>;

+

+fn foo(_: T) {}

+"#,

+ r#"

+struct A<'a, 'b>(pub &'a mut &'b mut ());

+

+

+

+fn foo(_: A) {}

+"#,

+ );

+ }

+

+ #[test]

+ fn mixed_lifetime_and_type_args() {

+ check_assist(

+ inline_type_alias,

+ r#"

+type Foo<'a, T> = Bar<'a, T>;

+struct Bar<'a, T>(&'a T);

+fn main() {

+ let a: $0Foo<u32>;

+}

+"#,

+ r#"

+type Foo<'a, T> = Bar<'a, T>;

+struct Bar<'a, T>(&'a T);

+fn main() {

+ let a: Bar<u32>;

+}

+"#,

+ );

+ }

+

+ ast::{self, AstNode, syntax_factory::SyntaxFactory},

+ utils::invert_boolean_expression,

+ let make = SyntaxFactory::without_mappings();

+ let flip_cond = invert_boolean_expression(&make, cond.clone());

+ let mut selected_nodes = parent_node.children().filter(|it| {

+ selection_range.intersect(it.text_range()).is_some_and(|it| !it.is_empty())

+ });

+ fn merge_partial_selection_uses() {

+ cov_mark::check!(merge_with_selected_use_item_neighbors);

+ check_assist(

+ merge_imports,

+ r"

+use std::fmt::Error;

+$0use std::fmt::Display;

+use std::fmt::Debug;

+use std::fmt::Write;

+use$0 std::fmt::Result;

+",

+ r"

+use std::fmt::Error;

+use std::fmt::{Debug, Display, Result, Write};

+",

+ );

+ }

+

+ #[test]

+ AstNode, BlockExpr, ElseBranch, Expr, IfExpr, MatchArm, Pat, edit::AstNodeEdit,

+ let make = SyntaxFactory::without_mappings();

+ let then_branch = crate::utils::wrap_block(&arm.expr()?, &make);

+ Some(make.expr_if(guard_condition, then_branch, else_branch).into())

+ arm.expr().map(|it| crate::utils::wrap_block(&it, &make).into())

+ edit.replace(element, make.whitespace(" "));

+use syntax::{AstNode, ast, ast::syntax_factory::SyntaxFactory};

+ let qualify_candidate = QualifyCandidate::ImplMethod(ctx.sema.db, call.clone(), resolved_call);

+ let make = SyntaxFactory::with_mappings();

+ let mut editor = builder.make_editor(call.syntax());

+ |_| {},

+ &mut editor,

+ &make,

+ );

+ editor.add_mappings(make.finish_with_mappings());

+ builder.add_file_edits(ctx.vfs_file_id(), editor);

+ ast::{HasArgList, syntax_factory::SyntaxFactory},

+ syntax_editor::SyntaxEditor,

+ let path = ast::Path::cast(syntax_under_caret.clone())?;

+ let path = ast::Path::cast(syntax_under_caret.clone())?;

+ let path = ast::Path::cast(syntax_under_caret.clone())?;

+ let mcall_expr = ast::MethodCallExpr::cast(syntax_under_caret.clone())?;

+ let make = SyntaxFactory::with_mappings();

+ let mut editor = builder.make_editor(&syntax_under_caret);

+ &mut editor,

+ &make,

+ );

+ editor.add_mappings(make.finish_with_mappings());

+ builder.add_file_edits(ctx.vfs_file_id(), editor);

+ editor: &mut SyntaxEditor,

+ make: &SyntaxFactory,

+ Self::qualify_trait_method(db, mcall_expr, editor, make, import, item);

+ Self::qualify_fn_call(db, mcall_expr, editor, make, import, hir_fn);

+ editor: &mut SyntaxEditor,

+ make: &SyntaxFactory,

+ hir::Access::Shared => make.expr_ref(receiver, false),

+ hir::Access::Exclusive => make.expr_ref(receiver, true),

+ Some(args) => make.arg_list(iter::once(receiver).chain(args)),

+ None => make.arg_list(iter::once(receiver)),

+ let call_path = make.path_from_text(&format!("{import}::{method_name}{generics}"));

+ let call_expr = make.expr_call(make.expr_path(call_path), arg_list);

+ editor.replace(mcall_expr.syntax(), call_expr.syntax());

+ editor: &mut SyntaxEditor,

+ make: &SyntaxFactory,

+ Self::qualify_fn_call(db, mcall_expr, editor, make, import, &method)

+use syntax::ast::{self, AstNode, HasArgList, prec::ExprPrecedence, syntax_factory::SyntaxFactory};

+use crate::{

+ AssistContext, AssistId, Assists,

+ utils::{cover_let_chain, wrap_paren, wrap_paren_in_call},

+};

+ let make = SyntaxFactory::with_mappings();

+ let (pat, predicate) = method_predicate(&call_expr, &var_name, &make);

+ let pat = make.tuple_struct_pat(make.ident_path(text), [pat]).into();

+ let predicate = wrap_paren(predicate, &make, ExprPrecedence::LAnd);

+fn method_predicate(

+ call_expr: &ast::MethodCallExpr,

+ name: &str,

+ make: &SyntaxFactory,

+) -> (ast::Pat, Option<ast::Expr>) {

+ let argument = call_expr.arg_list().and_then(|it| it.args().next());

+ if let Some(ast::Expr::ClosureExpr(it)) = argument.clone()

+ && let Some(pat) = it.param_list().and_then(|it| it.params().next()?.pat())

+ {

+ (pat, it.body())

+ } else {

+ let pat = make.ident_pat(false, false, make.name(name));

+ let expr = argument.map(|expr| {

+ let arg_list = make.arg_list([make.expr_path(make.ident_path(name))]);

+ make.expr_call(wrap_paren_in_call(expr, make), arg_list).into()

+ });

+ (pat.into(), expr)

+

+ check_assist(

+ replace_is_method_with_if_let_method,

+ r#"

+fn main() {

+ let x = Some(1);

+ if x.is_som$0e_and(|it| it != 3 || it > 10) {}

+}

+"#,

+ r#"

+fn main() {

+ let x = Some(1);

+ if let Some(it) = x && (it != 3 || it > 10) {}

+}

+"#,

+ );

+

+ check_assist(

+ replace_is_method_with_if_let_method,

+ r#"

+fn main() {

+ let x = Some(1);

+ if x.is_som$0e_and(predicate) {}

+}

+"#,

+ r#"

+fn main() {

+ let x = Some(1);

+ if let Some(x1) = x && predicate(x1) {}

+}

+"#,

+ );

+

+ check_assist(

+ replace_is_method_with_if_let_method,

+ r#"

+fn main() {

+ let x = Some(1);

+ if x.is_som$0e_and(func.f) {}

+}

+"#,

+ r#"

+fn main() {

+ let x = Some(1);

+ if let Some(x1) = x && (func.f)(x1) {}

+}

+"#,

+ );

+ let make = SyntaxFactory::without_mappings();

+ let fake_expr_let = make.expr_let(make.tuple_pat(None).into(), make.expr_unit());

+ ast::{self, Expr, HasArgList, make, syntax_factory::SyntaxFactory},

+use crate::{AssistContext, Assists, utils::wrap_paren_in_call};

+ let callable = wrap_paren_in_call(param.clone(), &SyntaxFactory::without_mappings());

+ ast::LetElse(it) => it.syntax().parent()?,

+ fn simple_let_else() {

+ check_assist(

+ unwrap_block,

+ r#"

+fn main() {

+ let Some(2) = None else {$0

+ return;

+ };

+}

+"#,

+ r#"

+fn main() {

+ return;

+}

+"#,

+ );

+ check_assist(

+ unwrap_block,

+ r#"

+fn main() {

+ let Some(2) = None else {$0

+ return

+ };

+}

+"#,

+ r#"

+fn main() {

+ return

+}

+"#,

+ );

+ }

+

+ #[test]

+use std::iter;

+

+use either::Either;

+ let let_stmt = let_kw.parent().and_then(Either::<ast::LetStmt, ast::LetExpr>::cast)?;

+ let mut indent_level = let_stmt.indent_level();

+ let pat = either::for_both!(&let_stmt, it => it.pat())?;

+ let (ty, init, prefix, suffix) = match &let_stmt {

+ Either::Left(let_stmt) => (let_stmt.ty(), let_stmt.initializer()?, "", ";"),

+ Either::Right(let_expr) => {

+ indent_level += 1;

+ (None, let_expr.expr()?, "&& ", "")

+ }

+ };

+ let mut decls = String::new();

+ let tys =

+ tuple_ty.into_iter().flat_map(|it| it.fields().map(Some)).chain(iter::repeat(None));

+ for (pat, ty, expr) in itertools::izip!(tuple_pat.fields(), tys, tuple_init.fields()) {

+ let ty = ty.map_or_else(String::new, |ty| format!(": {ty}"));

+ decls.push_str(&format!("{prefix}let {pat}{ty} = {expr}{suffix}\n{indent_level}"))

+

+ let s = decls.trim();

+ edit.replace(parent.text_range(), s.strip_prefix(prefix).unwrap_or(s));

+ fn unwrap_tuples_in_let_expr() {

+ check_assist(

+ unwrap_tuple,

+ r#"

+fn main() {

+ if $0let (foo, bar) = ("Foo", "Bar") {

+ code();

+ }

+}

+"#,

+ r#"

+fn main() {

+ if let foo = "Foo"

+ && let bar = "Bar" {

+ code();

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ ast::{self, AstNode, edit::AstNodeEdit, make, syntax_factory::SyntaxFactory},

+ WrapAttr(Vec<ast::Attr>),

+ WrapUnwrapOption::WrapAttr(vec![attr])

+ attempt_attr().unwrap_or_else(|| WrapUnwrapOption::WrapAttr(vec![attr]))

+ (Some(attr), _) => Some(WrapUnwrapOption::WrapAttr(vec![attr])),

+ NodeOrToken::Node(node) => {

+ if let Some(attr) = ast::Attr::cast(node.clone()) {

+ Some(WrapUnwrapOption::WrapAttr(vec![attr]))

+ } else {

+ let attrs = node

+ .children()

+ .filter(|it| it.text_range().intersect(ctx.selection_trimmed()).is_some())

+ .map(ast::Attr::cast)

+ .collect::<Option<Vec<_>>>()?;

+ if attrs.is_empty() {

+ return None;

+ }

+ Some(WrapUnwrapOption::WrapAttr(attrs))

+ }

+ }

+ WrapUnwrapOption::WrapAttr(attrs) => match &attrs[..] {

+ [attr] if attr.simple_name().as_deref() == Some("cfg_attr") => {

+ unwrap_cfg_attr(acc, attrs.into_iter().next().unwrap())

+ }

+ _ => wrap_cfg_attrs(acc, ctx, attrs),

+ },

+fn wrap_cfg_attrs(acc: &mut Assists, ctx: &AssistContext<'_>, attrs: Vec<ast::Attr>) -> Option<()> {

+ let (first_attr, last_attr) = (attrs.first()?, attrs.last()?);

+ let range = first_attr.syntax().text_range().cover(last_attr.syntax().text_range());

+ let path_attrs =

+ attrs.iter().map(|attr| Some((attr.path()?, attr.clone()))).collect::<Option<Vec<_>>>()?;

+ let mut editor = edit.make_editor(first_attr.syntax());

+ let mut raw_tokens = vec![];

+ for (path, attr) in path_attrs {

+ raw_tokens.extend([

+ NodeOrToken::Token(make.token(T![,])),

+ NodeOrToken::Token(make.whitespace(" ")),

+ ]);

+ path.syntax().descendants_with_tokens().for_each(|it| {

+ if let NodeOrToken::Token(token) = it {

+ raw_tokens.push(NodeOrToken::Token(token));

+ }

+ });

+ if let Some(meta) = attr.meta() {

+ if let (Some(eq), Some(expr)) = (meta.eq_token(), meta.expr()) {

+ raw_tokens.push(NodeOrToken::Token(make.whitespace(" ")));

+ raw_tokens.push(NodeOrToken::Token(eq));

+ raw_tokens.push(NodeOrToken::Token(make.whitespace(" ")));

+ expr.syntax().descendants_with_tokens().for_each(|it| {

+ if let NodeOrToken::Token(token) = it {

+ raw_tokens.push(NodeOrToken::Token(token));

+ }

+ });

+ } else if let Some(tt) = meta.token_tree() {

+ raw_tokens.extend(tt.token_trees_and_tokens());

+ }

+ let cfg_attr = if first_attr.excl_token().is_some() {

+ make.attr_inner(meta)

+ } else {

+ make.attr_outer(meta)

+ };

+ let syntax_range = first_attr.syntax().clone().into()..=last_attr.syntax().clone().into();

+ editor.replace_all(syntax_range, vec![cfg_attr.syntax().clone().into()]);

+ let inner_attrs =

+ inner_attrs.iter().map(|it| it.to_string()).join(&format!("\n{}", attr.indent_level()));

+ check_assist(

+ wrap_unwrap_cfg_attr,

+ r#"

+ pub struct Test {

+ #[other_attr]

+ $0#[foo]

+ #[bar]$0

+ #[other_attr]

+ test: u32,

+ }

+ "#,

+ r#"

+ pub struct Test {

+ #[other_attr]

+ #[cfg_attr($0, foo, bar)]

+ #[other_attr]

+ test: u32,

+ }

+ "#,

+ );

+ check_assist(

+ wrap_unwrap_cfg_attr,

+ r#"

+ pub struct Test {

+ #[cfg_attr(debug_assertions$0, foo, bar)]

+ test: u32,

+ }

+ "#,

+ r#"

+ pub struct Test {

+ #[foo]

+ #[bar]

+ test: u32,

+ }

+ "#,

+ );

+trait ${0:Create}<const N: usize> {

+impl<const N: usize> ${0:Create}<N> for Foo<N> {

+ prec::ExprPrecedence,

+pub(crate) fn wrap_block(expr: &ast::Expr, make: &SyntaxFactory) -> ast::BlockExpr {

+ make.block_expr(None, Some(expr.reset_indent().indent(1.into())))

+pub(crate) fn wrap_paren(expr: ast::Expr, make: &SyntaxFactory, prec: ExprPrecedence) -> ast::Expr {

+ if expr.precedence().needs_parentheses_in(prec) { make.expr_paren(expr).into() } else { expr }

+}

+

+pub(crate) fn wrap_paren_in_call(expr: ast::Expr, make: &SyntaxFactory) -> ast::Expr {

+ if needs_parens_in_call(&expr) { make.expr_paren(expr).into() } else { expr }

+}

+

+fn needs_parens_in_call(param: &ast::Expr) -> bool {

+ let call = make::expr_call(make::ext::expr_unit(), make::arg_list(Vec::new()));

+ let callable = call.expr().expect("invalid make call");

+ param.needs_parens_in_place_of(call.syntax(), callable.syntax())

+}

+

+ make: &SyntaxFactory,

+ .flat_map(|attr| [attr.syntax().clone().into(), make.whitespace(&whitespace).into()])

+pub(crate) fn convert_param_list_to_arg_list(

+ list: ast::ParamList,

+ make: &SyntaxFactory,

+) -> ast::ArgList {

+ let expr = make.expr_path(make.ident_path(&name));

+ make.arg_list(args)

+pub(crate) fn tt_from_syntax(

+ node: SyntaxNode,

+ make: &SyntaxFactory,

+) -> Vec<NodeOrToken<ast::TokenTree, SyntaxToken>> {

+ let sub_tt = make.token_tree(delimiter.expect("unbalanced delimiters"), tt);

+pub(crate) fn cover_edit_range(

+ source: &impl AstNode,

+ range: TextRange,

+) -> std::ops::RangeInclusive<syntax::SyntaxElement> {

+ let node = match source.syntax().covering_element(range) {

+ NodeOrToken::Node(node) => node,

+ NodeOrToken::Token(t) => t.parent().unwrap(),

+ };

+ let mut iter = node.children_with_tokens().filter(|it| range.contains_range(it.text_range()));

+ let first = iter.next().unwrap_or(node.into());

+ let last = iter.last().unwrap_or_else(|| first.clone());

+ first..=last

+}

+

+ ast::{self, FieldExpr, MethodCallExpr, syntax_factory::SyntaxFactory},

+ pub(crate) fn wrap_expr(&self, mut expr: ast::Expr, make: &SyntaxFactory) -> ast::Expr {

+ expr = make.expr_prefix(T![*], expr).into();

+ expr = make.expr_paren(expr).into();

+ let qualifier = param_qualifier(param);

+ let label = label.strip_prefix(qualifier.as_str()).unwrap_or(label);

+ let insert = if label.starts_with('#') {

+ // FIXME: `#[attr] it: i32` -> `#[attr] mut it: i32`

+ label.to_smolstr()

+ } else {

+ format_smolstr!("{qualifier}{label}")

+ };

+ let mk_item = |insert_text: &str, range: TextRange| {

+ let mut item =

+ CompletionItem::new(CompletionItemKind::Binding, range, label, ctx.edition);

+ if insert_text != label {

+ item.insert_text(insert_text);

+ }

+ item

+ Some((fmt, range)) => mk_item(&fmt(&insert), *range),

+ None => mk_item(&insert, ctx.source_range()),

+ if !is_simple_param(current_param) {

+ break;

+ }

+

+fn param_qualifier(param: &ast::Param) -> SmolStr {

+ let mut b = syntax::SmolStrBuilder::new();

+ if let Some(ast::Pat::IdentPat(pat)) = param.pat() {

+ if pat.ref_token().is_some() {

+ b.push_str("ref ");

+ }

+ if pat.mut_token().is_some() {

+ b.push_str("mut ");

+ }

+ }

+ b.finish()

+}

+ SyntaxKind::{CLOSURE_EXPR, EXPR_STMT, MATCH_ARM, STMT_LIST},

+ let semi =

+ if expr_ctx.in_block_expr && ctx.token.next_token().is_none_or(|it| it.kind() != T![;]) {

+ ";"

+ } else {

+ ""

+ };

+ postfix_snippet("let", "let", &format!("let $0 = {receiver_text}{semi}"))

+ postfix_snippet("letm", "let mut", &format!("let mut $0 = {receiver_text}{semi}"))

+ _ if matches!(parent.kind(), MATCH_ARM | CLOSURE_EXPR) => {

+ postfix_snippet("return", "return expr", &format!("return {receiver_text}{semi}"))

+ .add_to(acc, ctx.db);

+ postfix_snippet("break", "break expr", &format!("break {receiver_text}{semi}"))

+ .add_to(acc, ctx.db);

+ let text = file_text.text(sema.db);

+ let indent_spaces = indent_of_tail_line(&text[TextRange::up_to(range.range.start())]);

+ let mut text = stdx::dedent_by(indent_spaces, &text[range.range]);

+ return text;

+

+ fn indent_of_tail_line(text: &str) -> usize {

+ let tail_line = text.rsplit_once('\n').map_or(text, |(_, s)| s);

+ let trimmed = tail_line.trim_start_matches(' ');

+ tail_line.len() - trimmed.len()

+ }

+/// Given an `initial_element`, tries to expand it to include deref(s), and then references.

+/// Returns the expanded expressions, and the added prefix as a string

+///

+/// For example, if called with the `42` in `&&mut *42`, would return `(&&mut *42, "&&mut *")`.

+ && parent_deref_element.op_kind() == Some(ast::UnaryOp::Deref)

+ check_edit(

+ "let",

+ r#"

+fn main() {

+ baz.l$0

+ res

+}

+"#,

+ r#"

+fn main() {

+ let $0 = baz;

+ res

+}

+"#,

+ );

+

+ check_edit(

+ "let",

+ r#"

+fn main() {

+ baz.l$0

+}

+"#,

+ r#"

+fn main() {

+ let $0 = baz;

+}

+"#,

+ );

+

+ fn let_before_semicolon() {

+ check_edit(

+ "let",

+ r#"

+fn main() {

+ baz.l$0;

+}

+"#,

+ r#"

+fn main() {

+ let $0 = baz;

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn closure_let_block() {

+ check_edit(

+ "let",

+ r#"

+fn main() {

+ let bar = 2;

+ let f = || bar.$0;

+}

+"#,

+ r#"

+fn main() {

+ let bar = 2;

+ let f = || {

+ let $1 = bar;

+ $0

+};

+}

+"#,

+ );

+ }

+

+ #[test]

+ check_edit("dbg", r#"fn main() { &&*"hello".$0 }"#, r#"fn main() { dbg!(&&*"hello") }"#);

+ true => "\${1:placeholder}",

+ false => "\\\$",

+})

+

+ #[test]

+ fn snippet_dedent() {

+ check_edit(

+ "let",

+ r#"

+//- minicore: option

+fn foo(x: Option<i32>, y: Option<i32>) {

+ let _f = || {

+ x

+ .and(y)

+ .map(|it| it+2)

+ .$0

+ };

+}

+"#,

+ r#"

+fn foo(x: Option<i32>, y: Option<i32>) {

+ let _f = || {

+ let $0 = x

+ .and(y)

+ .map(|it| it+2);

+ };

+}

+"#,

+ );

+ }

+ ast::TupleStructPat(it) => {

+ let fields = it.path().and_then(|path| match sema.resolve_path(&path)? {

+ hir::PathResolution::Def(hir::ModuleDef::Adt(adt)) => Some(adt.as_struct()?.fields(sema.db)),

+ hir::PathResolution::Def(hir::ModuleDef::Variant(variant)) => Some(variant.fields(sema.db)),

+ _ => None,

+ });

+ let nr = it.fields().take_while(|it| it.syntax().text_range().end() <= token.text_range().start()).count();

+ let ty = fields.and_then(|fields| Some(fields.get(nr)?.ty(sema.db).to_type(sema.db)));

+ (ty, None)

+ },

+ Some(ast::Expr::Literal(l)) => {

+ matches!(l.kind(), ast::LiteralKind::FloatNumber { .. })

+ && l.syntax().last_token().is_some_and(|it| it.text().ends_with('.'))

+ }

+fn expected_type_tuple_struct_pat() {

+ check_expected_type_and_name(

+ r#"

+//- minicore: option

+struct Foo(Option<i32>);

+fn foo(x: Foo) -> Foo {

+ match x { Foo($0) => () }

+}

+"#,

+ expect![[r#"ty: Option<i32>, name: ?"#]],

+ );

+

+ check_expected_type_and_name(

+ r#"

+struct Foo(i32, u32, f32);

+fn foo(x: Foo) -> Foo {

+ match x { Foo($0) => () }

+}

+"#,

+ expect![[r#"ty: i32, name: ?"#]],

+ );

+

+ check_expected_type_and_name(

+ r#"

+struct Foo(i32, u32, f32);

+fn foo(x: Foo) -> Foo {

+ match x { Foo(num,$0) => () }

+}

+"#,

+ expect![[r#"ty: u32, name: ?"#]],

+ );

+

+ check_expected_type_and_name(

+ r#"

+struct Foo(i32, u32, f32);

+fn foo(x: Foo) -> Foo {

+ match x { Foo(num,$0,float) => () }

+}

+"#,

+ expect![[r#"ty: u32, name: ?"#]],

+ );

+}

+

+#[test]

+ "bar: u32",

+ // has unmatched mut kw

+ check_edit(

+ "bar: u32",

+ r#"

+fn f(foo: (), bar: u32) {}

+fn g(foo: (), mut ba$0)

+"#,

+ r#"

+fn f(foo: (), bar: u32) {}

+fn g(foo: (), mut bar: u32)

+"#,

+ );

+

+fn f(foo: (), mut bar: u32) {}

+fn g(foo: (), ba$0)

+"#,

+ r#"

+fn f(foo: (), mut bar: u32) {}

+fn g(foo: (), mut bar: u32)

+"#,

+ );

+

+ // has type param

+ check_edit(

+ "bar: u32",

+ r#"

+ "bar: u32",

+ r#"#[baz = "qux"] mut bar: u32"#,

+ bn file_id: usize

+ let (indent, offset, postfix, needs_comma) =

+ if let Some(last_field) = record_fields.fields().last() {

+ let indent = IndentLevel::from_node(last_field.syntax());

+ let offset = last_field.syntax().text_range().end();

+ let needs_comma = !last_field.to_string().ends_with(',');

+ (indent, offset, String::new(), needs_comma)

+ } else {

+ let indent = IndentLevel::from_node(record_fields.syntax());

+ let offset = record_fields.l_curly_token()?.text_range().end();

+ let postfix = if record_fields.syntax().text().contains_char('\n') {

+ ",".into()

+ } else {

+ format!(",\n{indent}")

+ };

+ (indent + 1, offset, postfix, false)

+ };

+ new_field = format!("\n{indent}{new_field}{postfix}");

+ TextEdit::insert(offset, new_field),

+ fn test_add_field_from_usage_with_empty_struct() {

+ check_fix(

+ r"

+fn main() {

+ Foo { bar$0: false };

+}

+struct Foo {}

+",

+ r"

+fn main() {

+ Foo { bar: false };

+}

+struct Foo {

+ bar: bool,

+}

+",

+ );

+

+ check_fix(

+ r"

+fn main() {

+ Foo { bar$0: false };

+}

+struct Foo {

+}

+",

+ r"

+fn main() {

+ Foo { bar: false };

+}

+struct Foo {

+ bar: bool,

+}

+",

+ );

+ }

+

+ #[test]

+use either::Either;

+use hir::Semantics;

+use ide_db::text_edit::TextEdit;

+use ide_db::ty_filter::TryEnum;

+use ide_db::{RootDatabase, source_change::SourceChange};

+use syntax::{AstNode, ast};

+

+use crate::{Assist, Diagnostic, DiagnosticCode, DiagnosticsContext, fix};

+ .with_fixes(fixes(&ctx.sema, d))

+}

+

+fn fixes(sema: &Semantics<'_, RootDatabase>, d: &hir::NonExhaustiveLet) -> Option<Vec<Assist>> {

+ let root = sema.parse_or_expand(d.pat.file_id);

+ let pat = d.pat.value.to_node(&root);

+ let let_stmt = ast::LetStmt::cast(pat.syntax().parent()?)?;

+ let early_node =

+ sema.ancestors_with_macros(let_stmt.syntax().clone()).find_map(AstNode::cast)?;

+ let early_text = early_text(sema, &early_node);

+

+ if let_stmt.let_else().is_some() {

+ return None;

+ }

+ let hir::FileRangeWrapper { file_id, range } = sema.original_range_opt(let_stmt.syntax())?;

+ let insert_offset = if let Some(semicolon) = let_stmt.semicolon_token()

+ && let Some(token) = sema.parse(file_id).syntax().token_at_offset(range.end()).left_biased()

+ && token.kind() == semicolon.kind()

+ {

+ token.text_range().start()

+ } else {

+ range.end()

+ };

+ let semicolon = if let_stmt.semicolon_token().is_none() { ";" } else { "" };

+ let else_block = format!(" else {{ {early_text} }}{semicolon}");

+ let file_id = file_id.file_id(sema.db);

+

+ let source_change =

+ SourceChange::from_text_edit(file_id, TextEdit::insert(insert_offset, else_block));

+ let target = sema.original_range(let_stmt.syntax()).range;

+ Some(vec![fix("add_let_else_block", "Add let-else block", source_change, target)])

+}

+

+fn early_text(

+ sema: &Semantics<'_, RootDatabase>,

+ early_node: &Either<ast::AnyHasLoopBody, Either<ast::Fn, ast::ClosureExpr>>,

+) -> &'static str {

+ match early_node {

+ Either::Left(_any_loop) => "continue",

+ Either::Right(Either::Left(fn_)) => sema

+ .to_def(fn_)

+ .map(|fn_def| fn_def.ret_type(sema.db))

+ .map(|ty| return_text(&ty, sema))

+ .unwrap_or("return"),

+ Either::Right(Either::Right(closure)) => closure

+ .body()

+ .and_then(|expr| sema.type_of_expr(&expr))

+ .map(|ty| return_text(&ty.adjusted(), sema))

+ .unwrap_or("return"),

+ }

+}

+

+fn return_text(ty: &hir::Type<'_>, sema: &Semantics<'_, RootDatabase>) -> &'static str {

+ if ty.is_unit() {

+ "return"

+ } else if let Some(try_enum) = TryEnum::from_ty(sema, ty) {

+ match try_enum {

+ TryEnum::Option => "return None",

+ TryEnum::Result => "return Err($0)",

+ }

+ } else {

+ "return $0"

+ }

+ use crate::tests::{check_diagnostics, check_fix};

+ //^^^^ 💡 error: non-exhaustive pattern: `Some(_)` not covered

+ //^^^^ 💡 error: non-exhaustive pattern: `Some(_)` not covered

+ //^^^^ 💡 error: non-exhaustive pattern: `Some(_)` not covered

+ //^^^^ 💡 error: non-exhaustive pattern: `Some(_)` not covered

+ //^^^^^^ 💡 error: non-exhaustive pattern: `Err(_)` not covered

+ fn fix_return_in_loop() {

+ check_fix(

+ r#"

+//- minicore: option

+fn foo() {

+ while cond {

+ let None$0 = Some(5);

+ }

+}

+"#,

+ r#"

+fn foo() {

+ while cond {

+ let None = Some(5) else { continue };

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn fix_return_in_fn() {

+ check_fix(

+ r#"

+//- minicore: option

+fn foo() {

+ let None$0 = Some(5);

+}

+"#,

+ r#"

+fn foo() {

+ let None = Some(5) else { return };

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn fix_return_in_macro_expanded() {

+ check_fix(

+ r#"

+//- minicore: option

+macro_rules! identity { ($($t:tt)*) => { $($t)* }; }

+fn foo() {

+ identity! {

+ let None$0 = Some(5);

+ }

+}

+"#,

+ r#"

+macro_rules! identity { ($($t:tt)*) => { $($t)* }; }

+fn foo() {

+ identity! {

+ let None = Some(5) else { return };

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn fix_return_in_incomplete_let() {

+ check_fix(

+ r#"

+//- minicore: option

+fn foo() {

+ let None$0 = Some(5)

+}

+"#,

+ r#"

+fn foo() {

+ let None = Some(5) else { return };

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn fix_return_in_closure() {

+ check_fix(

+ r#"

+//- minicore: option

+fn foo() -> Option<()> {

+ let _f = || {

+ let None$0 = Some(5);

+ };

+}

+"#,

+ r#"

+fn foo() -> Option<()> {

+ let _f = || {

+ let None = Some(5) else { return };

+ };

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn fix_return_try_in_fn() {

+ check_fix(

+ r#"

+//- minicore: option

+fn foo() -> Option<()> {

+ let None$0 = Some(5);

+}

+"#,

+ r#"

+fn foo() -> Option<()> {

+ let None = Some(5) else { return None };

+}

+"#,

+ );

+

+ check_fix(

+ r#"

+//- minicore: option, result

+fn foo() -> Result<(), i32> {

+ let None$0 = Some(5);

+}

+"#,

+ r#"

+fn foo() -> Result<(), i32> {

+ let None = Some(5) else { return Err($0) };

+}

+"#,

+ );

+ }

+

+ #[test]

+ indent += 1;

+ pub num_worker_threads: usize,

+ prime_caches::parallel_prime_caches(db, load_config.num_worker_threads, &|_| ());

+ let cargo_toml_path = Path::new(env!("CARGO_MANIFEST_DIR"))

+ .parent()

+ .unwrap()

+ .parent()

+ .unwrap()

+ .join("Cargo.toml");

+ let cargo_toml_path = AbsPathBuf::assert_utf8(cargo_toml_path);

+ let manifest = ProjectManifest::from_manifest_file(cargo_toml_path).unwrap();

+

+ num_worker_threads: 1,

+ let workspace = ProjectWorkspace::load(manifest, &cargo_config, &|_| {}).unwrap();

+ load_workspace(workspace, &cargo_config.extra_env, &load_cargo_config).unwrap();

+ /// Run tests matching a pattern (in RA, usually a path::to::module::of::tests)

+ /// May include {label} which will get the label from the `build` section of a crate.

+ /// May include {test_pattern} which will get the test module clicked on by the user.

+ TestMod,

+

+ /// Run a single doctest

+ /// May include {label} which will get the label from the `build` section of a crate.

+ /// May include {test_id} which will get the doctest clicked on by the user.

+ DocTestOne,

+

+ /// Run a single benchmark

+ /// May include {label} which will get the label from the `build` section of a crate.

+ /// May include {bench_id} which will get the benchmark clicked on by the user.

+ BenchOne,

+

+

+ /// For forwards-compatibility, i.e. old rust-analyzer binary with newer workspace discovery tools

+ Unknown,

+ //

+ // New fields should be Option or #[serde(default)]. This applies to most of this datastructure.

+struct BuildData {

+struct RunnableData {

+ program: String,

+ args: Vec<String>,

+ cwd: Utf8PathBuf,

+ kind: RunnableKindData,

+enum RunnableKindData {

+ TestMod,

+ DocTestOne,

+ BenchOne,

+

+ /// For forwards-compatibility, i.e. old rust-analyzer binary with newer workspace discovery tools

+ #[allow(unused)]

+ #[serde(other)]

+ Unknown,

+enum TargetKindData {

+ RunnableKindData::TestMod => RunnableKind::TestMod,

+ RunnableKindData::DocTestOne => RunnableKind::DocTestOne,

+ RunnableKindData::BenchOne => RunnableKind::BenchOne,

+ RunnableKindData::Unknown => RunnableKind::Unknown,

+fn rust_project_labeled_project_model() {

+ // This just needs to parse.

+ _ = load_rust_project("labeled-project.json");

+}

+

+#[test]

+{

+ "sysroot_src": null,

+ "crates": [

+ {

+ "display_name": "hello_world",

+ "root_module": "$ROOT$src/lib.rs",

+ "edition": "2018",

+ "deps": [],

+ "is_workspace_member": true,

+ "build": {

+ "label": "//:hello_world",

+ "build_file": "$ROOT$BUILD",

+ "target_kind": "bin"

+ }

+ }

+ ],

+ "runnables": [

+ {

+ "kind": "run",

+ "program": "bazel",

+ "args": ["run", "{label}"],

+ "cwd": "$ROOT$"

+ },

+ {

+ "kind": "flycheck",

+ "program": "$ROOT$custom-flychecker.sh",

+ "args": ["{label}"],

+ "cwd": "$ROOT$"

+ },

+ {

+ "kind": "we-ignore-unknown-runnable-kinds-for-forwards-compatibility",

+ "program": "abc",

+ "args": ["{label}"],

+ "cwd": "$ROOT$"

+ }

+ ]

+}

+ num_worker_threads: 1,

+ num_worker_threads: 1,

+

+ /// The number of worker threads for cache priming. Defaults to the number of physical cores.

+ optional --num-threads num_threads: usize

+ pub num_threads: Option<usize>,

+ num_worker_threads: 1,

+ num_worker_threads: 1,

+ num_worker_threads: 1,

+ num_worker_threads: 1,

+ num_worker_threads: self.num_threads.unwrap_or_else(num_cpus::get_physical),

+ num_worker_threads: 1,

+ num_worker_threads: 1,

+ num_worker_threads: 1,

+ /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically

+ /// the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).

+ /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically

+ /// the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).

+ /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically

+ /// the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).

+ num_worker_threads: 1,

+ num_worker_threads: 1,

+ num_worker_threads: 1,

+ fn trigger_garbage_collection(&mut self) {

+ if cfg!(test) {

+ // Slow tests run the main loop in multiple threads, but GC isn't thread safe.

+ return;

+ }

+

+ self.analysis_host.trigger_garbage_collection();

+ }

+

+ self.trigger_garbage_collection();

+ self.trigger_garbage_collection();

+ // When we're running multiple flychecks, we have to include a disambiguator in

+ // the title, or the editor complains. Note that this is a user-facing string.

+use project_model::project_json::{self, Runnable};

+ fn find_replace_runnable(

+ &self,

+ kind: project_json::RunnableKind,

+ replacer: &dyn Fn(&Self, &str) -> String,

+ ) -> Option<Runnable> {

+ for runnable in &self.shell_runnables {

+ if runnable.kind == kind {

+ let mut runnable = runnable.clone();

+

+ let replaced_args: Vec<_> =

+ runnable.args.iter().map(|arg| replacer(self, arg)).collect();

+ runnable.args = replaced_args;

+

+ return Some(runnable);

+ }

+ }

+

+ None

+ }

+

+ RunnableKind::Bin => self

+ .find_replace_runnable(project_json::RunnableKind::Run, &|this, arg| {

+ arg.replace("{label}", &this.label)

+ }),

+ self.find_replace_runnable(project_json::RunnableKind::Run, &|this, arg| {

+ arg.replace("{label}", &this.label).replace("{test_id}", &test_id.to_string())

+ })

+ }

+ RunnableKind::TestMod { path } => self

+ .find_replace_runnable(project_json::RunnableKind::TestMod, &|this, arg| {

+ arg.replace("{label}", &this.label).replace("{test_pattern}", path)

+ }),

+ RunnableKind::Bench { test_id } => {

+ self.find_replace_runnable(project_json::RunnableKind::BenchOne, &|this, arg| {

+ arg.replace("{label}", &this.label).replace("{bench_id}", &test_id.to_string())

+ })

+ }

+ RunnableKind::DocTest { test_id } => {

+ self.find_replace_runnable(project_json::RunnableKind::DocTestOne, &|this, arg| {

+ arg.replace("{label}", &this.label).replace("{test_id}", &test_id.to_string())

+ })

+ let executable_args = Self::executable_args_for(kind, extra_test_binary_args);

+ RunnableKind::Test { .. } => {

+ RunnableKind::TestMod { .. } => {

+ RunnableKind::Bench { .. } => {

+ RunnableKind::DocTest { .. } => {

+ let target = |kind, target| match kind {

+ TargetKind::Bin | TargetKind::Test | TargetKind::Bench | TargetKind::Example => target,

+ _ => "",

+ };

+

+ .replace("${target}", target(spec.target_kind, &spec.target))

+ let extra_test_binary_args = config.extra_test_binary_args;

+ let executable_args = Self::executable_args_for(kind, extra_test_binary_args);

+

+ args.map(|mut args| {

+ let exec_args_idx = args.iter().position(|a| a == "${executable_args}");

+

+ if let Some(idx) = exec_args_idx {

+ args.splice(idx..idx + 1, executable_args);

+ }

+

+ args.into_iter().map(replace_placeholders).filter(|a| !a.trim().is_empty()).collect()

+ })

+ }

+

+ fn executable_args_for(

+ kind: &RunnableKind,

+ extra_test_binary_args: impl IntoIterator<Item = String>,

+ ) -> Vec<String> {

+ let mut executable_args = Vec::new();

+

+ match kind {

+ RunnableKind::Test { test_id, attr } => {

+ executable_args.push(test_id.to_string());

+ if let TestId::Path(_) = test_id {

+ executable_args.push("--exact".to_owned());

+ }

+ executable_args.extend(extra_test_binary_args);

+ if attr.ignore {

+ executable_args.push("--ignored".to_owned());

+ }

+ }

+ RunnableKind::TestMod { path } => {

+ executable_args.push(path.clone());

+ executable_args.extend(extra_test_binary_args);

+ }

+ RunnableKind::Bench { test_id } => {

+ executable_args.push(test_id.to_string());

+ if let TestId::Path(_) = test_id {

+ executable_args.push("--exact".to_owned());

+ }

+ executable_args.extend(extra_test_binary_args);

+ }

+ RunnableKind::DocTest { test_id } => {

+ executable_args.push(test_id.to_string());

+ executable_args.extend(extra_test_binary_args);

+ }

+ RunnableKind::Bin => {}

+ }

+

+ executable_args

+ let indent = indent_of(text);

+#[must_use]

+fn indent_of(text: &str) -> usize {

+ text.lines()

+ .filter(|it| !it.trim().is_empty())

+ .map(|it| it.len() - it.trim_start().len())

+ .min()

+ .unwrap_or(0)

+}

+

+#[must_use]

+pub fn dedent_by(spaces: usize, text: &str) -> String {

+ text.split_inclusive('\n')

+ .map(|line| {

+ let trimmed = line.trim_start_matches(' ');

+ if line.len() - trimmed.len() <= spaces { trimmed } else { &line[spaces..] }

+ })

+ .collect()

+}

+

+ fn test_dedent() {

+ assert_eq!(dedent_by(0, ""), "");

+ assert_eq!(dedent_by(1, ""), "");

+ assert_eq!(dedent_by(2, ""), "");

+ assert_eq!(dedent_by(0, "foo"), "foo");

+ assert_eq!(dedent_by(2, "foo"), "foo");

+ assert_eq!(dedent_by(2, " foo"), "foo");

+ assert_eq!(dedent_by(2, " foo"), " foo");

+ assert_eq!(dedent_by(2, " foo\nbar"), " foo\nbar");

+ assert_eq!(dedent_by(2, "foo\n bar"), "foo\n bar");

+ assert_eq!(dedent_by(2, "foo\n\n bar"), "foo\n\n bar");

+ assert_eq!(dedent_by(2, "foo\n.\n bar"), "foo\n.\n bar");

+ assert_eq!(dedent_by(2, "foo\n .\n bar"), "foo\n.\n bar");

+ assert_eq!(dedent_by(2, "foo\n .\n bar"), "foo\n .\n bar");

+ }

+

+ #[test]

+ fn test_indent_of() {

+ assert_eq!(indent_of(""), 0);

+ assert_eq!(indent_of(" "), 0);

+ assert_eq!(indent_of(" x"), 1);

+ assert_eq!(indent_of(" x\n"), 1);

+ assert_eq!(indent_of(" x\ny"), 0);

+ assert_eq!(indent_of(" x\n y"), 1);

+ assert_eq!(indent_of(" x\n y"), 1);

+ assert_eq!(indent_of(" x\n y"), 2);

+ assert_eq!(indent_of(" x\n y\n"), 2);

+ assert_eq!(indent_of(" x\n\n y\n"), 2);

+ }

+

+ #[test]

+

+pub fn next_non_trivia_token(e: impl Into<SyntaxElement>) -> Option<SyntaxToken> {

+ let mut token = match e.into() {

+ SyntaxElement::Node(n) => n.last_token()?,

+ SyntaxElement::Token(t) => t,

+ }

+ .next_token();

+ while let Some(inner) = token {

+ if !inner.kind().is_trivia() {

+ return Some(inner);

+ } else {

+ token = inner.next_token();

+ }

+ }

+ None

+}

+impl ops::AddAssign<u8> for IndentLevel {

+ fn add_assign(&mut self, rhs: u8) {

+ self.0 += rhs;

+ }

+}

+

+ HasTypeBounds, HasVisibility, Lifetime, Param, RangeItem, make,

+ pub fn name_ref_self_ty(&self) -> ast::NameRef {

+ make::name_ref_self_ty().clone_for_update()

+ }

+

+ pub fn expr_todo(&self) -> ast::Expr {

+ make::ext::expr_todo().clone_for_update()

+ }

+

+ let ast = make::struct_(

+ visibility.clone(),

+ strukt_name.clone(),

+ generic_param_list.clone(),

+ field_list.clone(),

+ )

+ .clone_for_update();

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ if let Some(visibility) = visibility {

+ builder.map_node(

+ visibility.syntax().clone(),

+ ast.visibility().unwrap().syntax().clone(),

+ );

+ }

+ builder.map_node(strukt_name.syntax().clone(), ast.name().unwrap().syntax().clone());

+ if let Some(generic_param_list) = generic_param_list {

+ builder.map_node(

+ generic_param_list.syntax().clone(),

+ ast.generic_param_list().unwrap().syntax().clone(),

+ );

+ }

+ builder

+ .map_node(field_list.syntax().clone(), ast.field_list().unwrap().syntax().clone());

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let ast = make::unnamed_param(ty.clone()).clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let (params, params_input) = iterator_input(params);

+ let ast = make::ty_fn_ptr(is_unsafe, abi.clone(), params.into_iter(), ret_type.clone())

+ .clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ if let Some(abi) = abi {

+ builder.map_node(abi.syntax().clone(), ast.abi().unwrap().syntax().clone());

+ }

+ builder.map_children(

+ params_input,

+ ast.param_list().unwrap().params().map(|p| p.syntax().clone()),

+ );

+ if let Some(ret_type) = ret_type {

+ builder

+ .map_node(ret_type.syntax().clone(), ast.ret_type().unwrap().syntax().clone());

+ }

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let (bounds, bounds_input) = iterator_input(bounds);

+ let ast = make::where_pred(path.clone(), bounds).clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ match &path {

+ Either::Left(lifetime) => {

+ builder.map_node(

+ lifetime.syntax().clone(),

+ ast.lifetime().unwrap().syntax().clone(),

+ );

+ }

+ Either::Right(ty) => {

+ builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());

+ }

+ }

+ if let Some(type_bound_list) = ast.type_bound_list() {

+ builder.map_children(

+ bounds_input,

+ type_bound_list.bounds().map(|b| b.syntax().clone()),

+ );

+ }

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let (predicates, input) = iterator_input(predicates);

+ let ast = make::where_clause(predicates).clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ builder.map_children(input, ast.predicates().map(|p| p.syntax().clone()));

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let ast = make::impl_trait_type(bounds.clone()).clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ builder

+ .map_node(bounds.syntax().clone(), ast.type_bound_list().unwrap().syntax().clone());

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let (generic_args, input) = iterator_input(generic_args);

+ let ast = make::generic_ty_path_segment(name_ref.clone(), generic_args).clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ builder.map_node(name_ref.syntax().clone(), ast.name_ref().unwrap().syntax().clone());

+ builder.map_children(

+ input,

+ ast.generic_arg_list().unwrap().generic_args().map(|a| a.syntax().clone()),

+ );

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let ast = make::tail_only_block_expr(tail_expr.clone()).clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let stmt_list = ast.stmt_list().unwrap();

+ let mut builder = SyntaxMappingBuilder::new(stmt_list.syntax().clone());

+ builder.map_node(

+ tail_expr.syntax().clone(),

+ stmt_list.tail_expr().unwrap().syntax().clone(),

+ );

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let ast::Expr::BinExpr(ast) =

+ make::expr_bin_op(lhs.clone(), op, rhs.clone()).clone_for_update()

+ else {

+ unreachable!()

+ };

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ builder.map_node(lhs.syntax().clone(), ast.lhs().unwrap().syntax().clone());

+ builder.map_node(rhs.syntax().clone(), ast.rhs().unwrap().syntax().clone());

+ builder.finish(&mut mapping);

+ }

+

+ ast.into()

+ let (attrs, attrs_input) = iterator_input(attrs);

+ let ast = make::use_(attrs, visibility.clone(), use_tree.clone()).clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ builder.map_children(attrs_input, ast.attrs().map(|attr| attr.syntax().clone()));

+ if let Some(visibility) = visibility {

+ builder.map_node(

+ visibility.syntax().clone(),

+ ast.visibility().unwrap().syntax().clone(),

+ );

+ }

+ builder.map_node(use_tree.syntax().clone(), ast.use_tree().unwrap().syntax().clone());

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ let ast = make::use_tree(path.clone(), use_tree_list.clone(), alias.clone(), add_star)

+ .clone_for_update();

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());

+ if let Some(use_tree_list) = use_tree_list {

+ builder.map_node(

+ use_tree_list.syntax().clone(),

+ ast.use_tree_list().unwrap().syntax().clone(),

+ );

+ }

+ if let Some(alias) = alias {

+ builder.map_node(alias.syntax().clone(), ast.rename().unwrap().syntax().clone());

+ }

+ builder.finish(&mut mapping);

+ }

+

+ ast

+

+ pub fn field_from_idents<'a>(

+ &self,

+ parts: impl std::iter::IntoIterator<Item = &'a str>,

+ ) -> Option<ast::Expr> {

+ make::ext::field_from_idents(parts)

+ }

+

+ pub fn expr_await(&self, expr: ast::Expr) -> ast::AwaitExpr {

+ let ast::Expr::AwaitExpr(ast) = make::expr_await(expr.clone()).clone_for_update() else {

+ unreachable!()

+ };

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ }

+

+ pub fn expr_break(&self, label: Option<Lifetime>, expr: Option<ast::Expr>) -> ast::BreakExpr {

+ let ast::Expr::BreakExpr(ast) =

+ make::expr_break(label.clone(), expr.clone()).clone_for_update()

+ else {

+ unreachable!()

+ };

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ if let Some(label) = label {

+ builder.map_node(label.syntax().clone(), ast.lifetime().unwrap().syntax().clone());

+ }

+ if let Some(expr) = expr {

+ builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());

+ }

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ }

+

+ pub fn expr_continue(&self, label: Option<Lifetime>) -> ast::ContinueExpr {

+ let ast::Expr::ContinueExpr(ast) = make::expr_continue(label.clone()).clone_for_update()

+ else {

+ unreachable!()

+ };

+

+ if let Some(mut mapping) = self.mappings() {

+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());

+ if let Some(label) = label {

+ builder.map_node(label.syntax().clone(), ast.lifetime().unwrap().syntax().clone());

+ }

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ }

+Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically

+the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).

+Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically

+the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).

+Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically

+the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).

+ "version": "3.4.2",

+ "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",

+ "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",

+ "version": "6.24.1",

+ "resolved": "https://registry.npmjs.org/undici/-/undici-6.24.1.tgz",

+ "integrity": "sha512-sC+b0tB1whOCzbtlx20fx3WgCXwkW627p4EA9uM+/tNNPkSS+eSEld6pAs9nDv7WbY1UUljBMYPtu9BCOrCWKA==",

+ "markdownDescription": "Override the command used for bench runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).",

+ "markdownDescription": "Override the command used for bench runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).",

+ "markdownDescription": "Override the command used for test runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).",