+ rustup component add --toolchain stable rust-src rustfmt

+ clippy:

+ if: github.repository == 'rust-lang/rust-analyzer'

+ runs-on: ubuntu-latest

+

+ steps:

+ - name: Checkout repository

+ uses: actions/checkout@v4

+

+ # Note that clippy output is currently dependent on whether rust-src is installed,

+ # https://github.com/rust-lang/rust-clippy/issues/14625

+ - name: Install Rust toolchain

+ run: |

+ rustup update --no-self-update stable

+ rustup default stable

+ rustup component add --toolchain stable rust-src clippy

+

+ # https://github.com/actions-rust-lang/setup-rust-toolchain/blob/main/rust.json

+ - name: Install Rust Problem Matcher

+ run: echo "::add-matcher::.github/rust.json"

+

+ - run: cargo clippy --all-targets -- -D clippy::disallowed_macros -D clippy::dbg_macro -D clippy::todo -D clippy::print_stdout -D clippy::print_stderr

+

+ # FIXME: Pin nightly due to a regression in miri on nightly-2026-02-12.

+ # See https://github.com/rust-lang/miri/issues/4855.

+ # Revert to plain `nightly` once this is fixed upstream.

+ rustup toolchain install nightly-2026-02-10

+ rustup default nightly-2026-02-10

+ needs: [rust, rust-cross, typescript, typo-check, proc-macro-srv, miri, rustfmt, clippy, analysis-stats]

+ "rayon",

+version = "0.25.2"

+checksum = "e2e2aa2fca57727371eeafc975acc8e6f4c52f8166a78035543f6ee1c74c2dcc"

+version = "0.25.2"

+checksum = "1bfc2a1e7bf06964105515451d728f2422dedc3a112383324a00b191a5c397a3"

+version = "0.25.2"

+checksum = "3d844c1aa34946da46af683b5c27ec1088a3d9d84a2b837a108223fd830220e1"

+salsa = { version = "0.25.2", default-features = false, features = [

+salsa-macros = "0.25.2"

+ impl zalsa_struct_::HashEqLike<WithoutCrate> for EditionedFileIdData {

+ AdtId, BlockId, BlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId, ItemContainerId,

+ MacroId, ModuleDefId, ModuleId, TraitId, TypeAliasId, UnresolvedMacro,

+ let is_extern = matches!(

+ owner,

+ DefWithBodyId::FunctionId(id)

+ if matches!(id.loc(db).container, ItemContainerId::ExternBlockId(_)),

+ );

+

+ let param_pat = if is_extern {

+ collector.collect_extern_fn_param(param.pat())

+ } else {

+ collector.collect_pat_top(param.pat())

+ };

+ fn collect_extern_fn_param(&mut self, pat: Option<ast::Pat>) -> PatId {

+ // `extern` functions cannot have pattern-matched parameters, and furthermore, the identifiers

+ // in their parameters are always interpreted as bindings, even if in a normal function they

+ // won't be, because they would refer to a path pattern.

+ let Some(pat) = pat else { return self.missing_pat() };

+

+ match &pat {

+ ast::Pat::IdentPat(bp) => {

+ // FIXME: Emit an error if `!bp.is_simple_ident()`.

+

+ let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);

+ let hygiene = bp

+ .name()

+ .map(|name| self.hygiene_id_for(name.syntax().text_range()))

+ .unwrap_or(HygieneId::ROOT);

+ let binding = self.alloc_binding(name, BindingAnnotation::Unannotated, hygiene);

+ let pat =

+ self.alloc_pat(Pat::Bind { id: binding, subpat: None }, AstPtr::new(&pat));

+ self.add_definition_to_binding(binding, pat);

+ pat

+ }

+ // FIXME: Emit an error.

+ _ => self.missing_pat(),

+ }

+ }

+

+ pub(crate) fn remove_from_value_ns(&mut self, name: &Name, def: ModuleDefId) {

+ let entry = self.values.shift_remove(name);

+ assert!(entry.is_some_and(|entry| entry.def == def))

+ }

+

+ fn_proc_macro_mapping_back: FxHashMap<ProcMacroId, FunctionId>,

+ fn_proc_macro_mapping_back: FxHashMap::default(),

+ fn_proc_macro_mapping_back,

+ fn_proc_macro_mapping_back.shrink_to_fit();

+ pub fn proc_macro_as_fn(&self, id: ProcMacroId) -> Option<FunctionId> {

+ self.data.fn_proc_macro_mapping_back.get(&id).copied()

+ }

+

+ crate_data.fn_proc_macro_mapping_back.insert(proc_macro_id, fn_id);

+ update_def(self.def_collector, fn_id.into(), &it.name, vis, false);

+

+ // A proc macro is implemented as a function, but it's treated as a macro, not a function.

+ // You cannot call it like a function, for example, except in its defining crate.

+ // So we keep the function definition, but remove it from the scope, leaving only the macro.

+ self.def_collector.def_map[module_id]

+ .scope

+ .remove_from_value_ns(&it.name, fn_id.into());

+ }

+ - attribute_macro : macro#

+ - function_like_macro : macro!

+ item_scope::{BUILTIN_SCOPE, BuiltinShadowMode, ImportOrExternCrate, ItemScope},

+ ValueNs(ValueNs),

+ Partial(TypeNs, usize),

+ ResolveValueResult::ValueNs(match *l {

+ LangItemTarget::FunctionId(it) => ValueNs::FunctionId(it),

+ LangItemTarget::StaticId(it) => ValueNs::StaticId(it),

+ LangItemTarget::StructId(it) => ValueNs::StructId(it),

+ LangItemTarget::EnumVariantId(it) => ValueNs::EnumVariantId(it),

+ LangItemTarget::UnionId(_)

+ | LangItemTarget::ImplId(_)

+ | LangItemTarget::TypeAliasId(_)

+ | LangItemTarget::TraitId(_)

+ | LangItemTarget::EnumId(_) => return None,

+ }),

+ ResolveValueResult::Partial(type_ns, 0),

+ ResolveValueResult::ValueNs(ValueNs::LocalBinding(e.binding())),

+ ResolveValueResult::ValueNs(ValueNs::ImplSelf(impl_)),

+ ResolveValueResult::ValueNs(val),

+ ResolveValueResult::Partial(TypeNs::SelfType(impl_), 1),

+ ResolveValueResult::Partial(ty, 1),

+ ResolveValueResult::Partial(ty, 1),

+ ResolveValueResult::Partial(TypeNs::BuiltinType(builtin), 1),

+ ResolveValueResult::ValueNs(it) => Some(it),

+ let value = to_value_ns(module_def, self.def_map)?;

+ Some((ResolveValueResult::ValueNs(value), prefix_info))

+ let def = module_def.take_types()?;

+ let ty = match def {

+ Some((ResolveValueResult::Partial(ty, unresolved_idx), prefix_info))

+fn to_value_ns(per_ns: PerNs, def_map: &DefMap) -> Option<ValueNs> {

+ let def = per_ns.take_values().or_else(|| {

+ let Some(MacroId::ProcMacroId(proc_macro)) = per_ns.take_macros() else { return None };

+ // If we cannot resolve to value ns, but we can resolve to a proc macro, and this is the crate

+ // defining this proc macro - inside this crate, we should treat the macro as a function.

+ def_map.proc_macro_as_fn(proc_macro).map(ModuleDefId::FunctionId)

+ })?;

+ Some(res)

+ if let Some(ResolveValueResult::ValueNs(ValueNs::StaticId(id))) = value_or_partial {

+ ResolveValueResult::ValueNs(value) => match value {

+ ResolveValueResult::Partial(typens, unresolved) => (typens, Some(unresolved)),

+ self.infer_expr_coerce(value, &Expectation::has_type(lhs_ty), ExprIsRead::Yes);

+ res |= matches!(body[pat], Pat::Bind { id, .. } if matches!(body[id].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut));

+ ResolveValueResult::ValueNs(it) => {

+ ResolveValueResult::Partial(def, remaining_index) => {

+ ResolveValueResult::Partial(_, unresolved_segment) => {

+ ResolveValueResult::ValueNs(ValueNs::EnumVariantId(_)) if prefix_info.enum_variant => {

+ ResolveValueResult::ValueNs(resolution) => {

+ ResolveValueResult::Partial(resolution, _) => {

+ rustc_type_ir::FloatTy::F64 => Owned(value.to_le_bytes().to_vec()),

+ ResolveValueResult::ValueNs(v) => {

+ ResolveValueResult::Partial(_, _) => {

+ ResolveValueResult::ValueNs(ValueNs::LocalBinding(binding)),

+ if let ResolveValueResult::ValueNs(ValueNs::ConstId(c)) = pr {

+ PredicateKind::Clause(ClauseKind::WellFormed(_)) | PredicateKind::AliasRelate(..) => {

+ false

+ }

+ | PredicateKind::NormalizesTo(..)

+fn diverging_place_match_ref_mut() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn coerce_ref_mut_binding() -> ! {

+ unsafe {

+ let x: *mut ! = 0 as _;

+ let ref mut _x: () = *x;

+ }

+}

+"#,

+ expect![[r#"

+ 33..120 '{ ... } }': !

+ 39..118 'unsafe... }': !

+ 60..61 'x': *mut !

+ 72..73 '0': i32

+ 72..78 '0 as _': *mut !

+ 92..102 'ref mut _x': &'? mut ()

+ 109..111 '*x': !

+ 110..111 'x': *mut !

+ 109..111: expected (), got !

+ "#]],

+ )

+}

+

+#[test]

+fn assign_never_place_no_mismatch() {

+ check_no_mismatches(

+ r#"

+//- minicore: sized

+fn foo() {

+ unsafe {

+ let p: *mut ! = 0 as _;

+ let mut x: () = ();

+ x = *p;

+ }

+}

+"#,

+ );

+}

+

+#[test]

+

+#[test]

+fn regression_21605() {

+ check_infer(

+ r#"

+//- minicore: fn, coerce_unsized, dispatch_from_dyn, iterator, iterators

+pub struct Filter<'a, 'b, T>

+where

+ T: 'b,

+ 'a: 'b,

+{

+ filter_fn: dyn Fn(&'a T) -> bool,

+ t: Option<T>,

+ b: &'b (),

+}

+

+impl<'a, 'b, T> Filter<'a, 'b, T>

+where

+ T: 'b,

+ 'a: 'b,

+{

+ pub fn new(filter_fn: dyn Fn(&T) -> bool) -> Self {

+ Self {

+ filter_fn: filter_fn,

+ t: None,

+ b: &(),

+ }

+ }

+}

+

+pub trait FilterExt<T> {

+ type Output;

+ fn filter(&self, filter: &Filter<T>) -> Self::Output;

+}

+

+impl<const N: usize, T> FilterExt<T> for [T; N]

+where

+ T: IntoIterator,

+{

+ type Output = T;

+ fn filter(&self, filter: &Filter<T>) -> Self::Output {

+ let _ = self.into_iter().filter(filter.filter_fn);

+ loop {}

+ }

+}

+"#,

+ expect![[r#"

+ 214..223 'filter_fn': dyn Fn(&'? T) -> bool + 'static

+ 253..360 '{ ... }': Filter<'a, 'b, T>

+ 263..354 'Self {... }': Filter<'a, 'b, T>

+ 293..302 'filter_fn': dyn Fn(&'? T) -> bool + 'static

+ 319..323 'None': Option<T>

+ 340..343 '&()': &'? ()

+ 341..343 '()': ()

+ 421..425 'self': &'? Self

+ 427..433 'filter': &'? Filter<'?, '?, T>

+ 580..584 'self': &'? [T; N]

+ 586..592 'filter': &'? Filter<'?, '?, T>

+ 622..704 '{ ... }': T

+ 636..637 '_': Filter<Iter<'?, T>, dyn Fn(&'? T) -> bool + '?>

+ 640..644 'self': &'? [T; N]

+ 640..656 'self.i...iter()': Iter<'?, T>

+ 640..681 'self.i...er_fn)': Filter<Iter<'?, T>, dyn Fn(&'? T) -> bool + '?>

+ 664..670 'filter': &'? Filter<'?, '?, T>

+ 664..680 'filter...ter_fn': dyn Fn(&'? T) -> bool + 'static

+ 691..698 'loop {}': !

+ 696..698 '{}': ()

+ "#]],

+ );

+}

+

+#[test]

+fn extern_fns_cannot_have_param_patterns() {

+ check_no_mismatches(

+ r#"

+pub(crate) struct Builder<'a>(&'a ());

+

+unsafe extern "C" {

+ pub(crate) fn foo<'a>(Builder: &Builder<'a>);

+}

+ "#,

+ );

+}

+

+#[test]

+fn proc_macros_are_functions_inside_defining_crate_and_macros_outside() {

+ check_types(

+ r#"

+//- /pm.rs crate:pm

+#![crate_type = "proc-macro"]

+

+#[proc_macro_attribute]

+pub fn proc_macro() {}

+

+fn foo() {

+ proc_macro;

+ // ^^^^^^^^^^ fn proc_macro()

+}

+

+mod bar {

+ use super::proc_macro;

+

+ fn baz() {

+ super::proc_macro;

+ // ^^^^^^^^^^^^^^^^^ fn proc_macro()

+ proc_macro;

+ // ^^^^^^^^^^ fn proc_macro()

+ }

+}

+

+//- /lib.rs crate:lib deps:pm

+fn foo() {

+ pm::proc_macro;

+ // ^^^^^^^^^^^^^^ {unknown}

+}

+ "#,

+ );

+}

+ let too_long_param = data.params.len() > 4;

+ if too_long_param {

+ f.write_str("\n ")?;

+ }

+

+ let comma = if too_long_param { ",\n " } else { ", " };

+ f.write_str(comma)?;

+ f.write_str(comma)?;

+ if too_long_param {

+ f.write_char('\n')?;

+ }

+

+ /// Returns an iterator over the inferred types of all expressions in this body.

+ pub fn expression_types<'db>(

+ self,

+ db: &'db dyn HirDatabase,

+ ) -> impl Iterator<Item = Type<'db>> {

+ self.id().into_iter().flat_map(move |def_id| {

+ let infer = InferenceResult::for_body(db, def_id);

+ let resolver = def_id.resolver(db);

+

+ infer.expression_types().map(move |(_, ty)| Type::new_with_resolver(db, &resolver, ty))

+ })

+ }

+

+ /// Returns an iterator over the inferred types of all patterns in this body.

+ pub fn pattern_types<'db>(self, db: &'db dyn HirDatabase) -> impl Iterator<Item = Type<'db>> {

+ self.id().into_iter().flat_map(move |def_id| {

+ let infer = InferenceResult::for_body(db, def_id);

+ let resolver = def_id.resolver(db);

+

+ infer.pattern_types().map(move |(_, ty)| Type::new_with_resolver(db, &resolver, ty))

+ })

+ }

+

+ /// Returns an iterator over the inferred types of all bindings in this body.

+ pub fn binding_types<'db>(self, db: &'db dyn HirDatabase) -> impl Iterator<Item = Type<'db>> {

+ self.id().into_iter().flat_map(move |def_id| {

+ let infer = InferenceResult::for_body(db, def_id);

+ let resolver = def_id.resolver(db);

+

+ infer.binding_types().map(move |(_, ty)| Type::new_with_resolver(db, &resolver, ty))

+ })

+ }

+ match ctx.probe_for_name(method_resolution::Mode::Path, name.clone(), self_ty) {

+ hir::attach_db(&db, || auto_import(&mut acc, &ctx));

+

+ #[test]

+ fn with_after_segments() {

+ let before = r#"

+mod foo {

+ pub mod wanted {

+ pub fn abc() {}

+ }

+}

+

+mod bar {

+ pub mod wanted {}

+}

+

+mod baz {

+ pub fn wanted() {}

+}

+

+mod quux {

+ pub struct wanted;

+}

+impl quux::wanted {

+ fn abc() {}

+}

+

+fn f() {

+ wanted$0::abc;

+}

+ "#;

+ check_auto_import_order(before, &["Import `foo::wanted`", "Import `quux::wanted`"]);

+ }

+ ast::{self, HasName, edit::AstNodeEdit},

+use syntax::ast::edit::AstNodeEdit;

+ ast::{self, HasName, edit::IndentLevel, make},

+ let enum_def = make_bool_enum(make_enum_pub).reset_indent().indent(indent);

+use syntax::ast::edit::AstNodeEdit;

+ let match_ = match_.reset_indent();

+ let match_ = match_.indent(let_stmt.indent_level());

+ imports::insert_use::{ImportScope, insert_use_with_editor},

+ ast::{

+ self, HasName,

+ edit::{AstNodeEdit, IndentLevel},

+ syntax_factory::SyntaxFactory,

+ },

+ match_ast,

+ syntax_editor::SyntaxEditor,

+ let mut syntax_editor = edit.make_editor(ret_type.syntax());

+ let syntax_factory = SyntaxFactory::with_mappings();

+ &syntax_factory,

+ syntax_editor.replace(

+ syntax_factory.ret_type(syntax_factory.ty(&struct_name)).syntax(),

+ replace_body_return_values(

+ &mut syntax_editor,

+ &syntax_factory,

+ ast::Expr::BlockExpr(fn_body),

+ &struct_name,

+ );

+ syntax_editor.add_mappings(syntax_factory.finish_with_mappings());

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

+

+ let Some(first_ref) = references.first() else { continue };

+

+ let mut editor = edit.make_editor(first_ref.name.syntax().as_node().unwrap());

+ let syntax_factory = SyntaxFactory::with_mappings();

+ let refs_with_imports = augment_references_with_imports(

+ &syntax_factory,

+ ctx,

+ references,

+ struct_name,

+ target_module,

+ );

+ editor.replace(

+ syntax_factory.ret_type(syntax_factory.ty(struct_name)).syntax(),

+ replace_body_return_values(

+ &mut editor,

+ &syntax_factory,

+ ast::Expr::BlockExpr(fn_body),

+ struct_name,

+ );

+ editor.replace(

+ syntax_factory

+ .tuple_struct_pat(

+ syntax_factory.path_from_text(struct_name),

+ tuple_pat.fields(),

+ )

+ .syntax(),

+ insert_use_with_editor(

+ &import_scope,

+ path,

+ &ctx.config.insert_use,

+ &mut editor,

+ &syntax_factory,

+ );

+ });

+

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

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

+ syntax_factory: &SyntaxFactory,

+ let import_scope = ImportScope::find_insert_use_container(name.syntax(), &ctx.sema);

+ syntax_factory.path_concat(

+ syntax_factory.path_from_text(struct_name),

+ (name, import_data)

+ syntax_factory: &SyntaxFactory,

+ let visibility = if make_struct_pub { Some(syntax_factory.visibility_pub()) } else { None };

+ let field_list = ast::FieldList::TupleFieldList(syntax_factory.tuple_field_list(

+ tuple_ty.fields().map(|ty| syntax_factory.tuple_field(visibility.clone(), ty)),

+ let struct_name = syntax_factory.name(struct_name);

+ let struct_def = syntax_factory.struct_(visibility, struct_name, None, field_list);

+ let struct_def = struct_def.indent(indent);

+fn replace_body_return_values(

+ syntax_editor: &mut SyntaxEditor,

+ syntax_factory: &SyntaxFactory,

+ body: ast::Expr,

+ struct_name: &str,

+) {

+ let struct_constructor = syntax_factory.expr_call(

+ syntax_factory.expr_path(syntax_factory.ident_path(struct_name)),

+ syntax_factory.arg_list(tuple_expr.fields()),

+ );

+ syntax_editor.replace(ret_expr.syntax(), struct_constructor.syntax());

+ ast::{self, AstNode, FieldExpr, HasName, IdentPat, syntax_factory::SyntaxFactory},

+ syntax_editor::{Position, SyntaxEditor},

+ let mut syntax_editor = edit.make_editor(data.ident_pat.syntax());

+ let syntax_factory = SyntaxFactory::with_mappings();

+ let assignment_edit =

+ edit_tuple_assignment(ctx, edit, &mut syntax_editor, &syntax_factory, data, in_sub_pattern);

+ let current_file_usages_edit = edit_tuple_usages(data, ctx, &syntax_factory, in_sub_pattern);

+

+ assignment_edit.apply(&mut syntax_editor, &syntax_factory);

+ usages_edit.into_iter().for_each(|usage_edit| usage_edit.apply(edit, &mut syntax_editor))

+

+ syntax_editor.add_mappings(syntax_factory.finish_with_mappings());

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

+ editor: &mut SyntaxEditor,

+ make: &SyntaxFactory,

+ .map(|name| ast::Pat::from(make.ident_pat(is_ref, is_mut, make.name(name))));

+ make.tuple_pat(fields)

+ let is_shorthand_field = data

+ .ident_pat

+ let annotation = edit.make_tabstop_before(cap);

+ editor.add_annotation(

+ first_pat.name().expect("first ident pattern should have a name").syntax(),

+ annotation,

+ );

+ AssignmentEdit {

+ ident_pat: data.ident_pat.clone(),

+ tuple_pat,

+ in_sub_pattern,

+ is_shorthand_field,

+ }

+ fn apply(self, syntax_editor: &mut SyntaxEditor, syntax_mapping: &SyntaxFactory) {

+ self.ident_pat.set_pat_with_editor(

+ Some(self.tuple_pat.into()),

+ syntax_editor,

+ syntax_mapping,

+ )

+ syntax_editor.insert(Position::after(self.ident_pat.syntax()), self.tuple_pat.syntax());

+ syntax_editor

+ .insert(Position::after(self.ident_pat.syntax()), syntax_mapping.whitespace(" "));

+ syntax_editor

+ .insert(Position::after(self.ident_pat.syntax()), syntax_mapping.token(T![:]));

+ syntax_editor.replace(self.ident_pat.syntax(), self.tuple_pat.syntax())

+ make: &SyntaxFactory,

+ .filter_map(|r| edit_tuple_usage(ctx, make, r, data, in_sub_pattern))

+ make: &SyntaxFactory,

+ Some(index) => Some(edit_tuple_field_usage(ctx, make, data, index)),

+ make: &SyntaxFactory,

+ let field_name = make.expr_path(make.ident_path(field_name));

+ EditTupleUsage::ReplaceExpr(replace_expr, ref_data.wrap_expr_with_factory(field_name, make))

+ EditTupleUsage::ReplaceExpr(index.field_expr.into(), field_name)

+ fn apply(self, edit: &mut SourceChangeBuilder, syntax_editor: &mut SyntaxEditor) {

+ syntax_editor.replace(target_expr.syntax(), replace_with.syntax())

+ ast::{

+ self, AstNode, HasGenericParams, HasName, HasVisibility, edit::AstNodeEdit,

+ syntax_factory::SyntaxFactory,

+ },

+ syntax_editor::Position,

+ utils::{convert_reference_type, find_struct_impl},

+ syntax_factory: &SyntaxFactory,

+ let self_expr = syntax_factory.expr_path(syntax_factory.ident_path("self"));

+ syntax_factory.ty_ref(record_field_info.field_ty.clone(), true),

+ syntax_factory.expr_ref(

+ syntax_factory.expr_field(self_expr, &record_field_info.field_name.text()).into(),

+ syntax_factory.ty_ref(record_field_info.field_ty.clone(), false),

+ syntax_factory.expr_ref(

+ syntax_factory

+ .expr_field(

+ syntax_factory.expr_path(syntax_factory.ident_path("self")),

+ &record_field_info.field_name.text(),

+ )

+ .into(),

+ syntax_factory.mut_self_param()

+ syntax_factory.self_param()

+ let fn_name = syntax_factory.name(&record_field_info.fn_name);

+ let params = syntax_factory.param_list(Some(self_param), []);

+ let ret_type = Some(syntax_factory.ret_type(ty));

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

+ syntax_factory.fn_(

+fn generate_setter_from_info(

+ info: &AssistInfo,

+ record_field_info: &RecordFieldInfo,

+ syntax_factory: &SyntaxFactory,

+) -> ast::Fn {

+ let fn_name = syntax_factory.name(&format!("set_{field_name}"));

+ let field_param = syntax_factory.param(

+ syntax_factory.ident_pat(false, false, syntax_factory.name(field_name)).into(),

+ field_ty.clone(),

+ );

+ let params = syntax_factory.param_list(Some(syntax_factory.mut_self_param()), [field_param]);

+ let self_expr = syntax_factory.expr_path(syntax_factory.ident_path("self"));

+ let lhs = syntax_factory.expr_field(self_expr, field_name);

+ let rhs = syntax_factory.expr_path(syntax_factory.ident_path(field_name));

+ let assign_stmt =

+ syntax_factory.expr_stmt(syntax_factory.expr_assignment(lhs.into(), rhs).into());

+ let body = syntax_factory.block_expr([assign_stmt.into()], None);

+ syntax_factory.fn_(

+ let syntax_factory = SyntaxFactory::without_mappings();

+ let items: Vec<ast::AssocItem> = info_of_record_fields

+ .iter()

+ .map(|record_field_info| {

+ let method = match assist_info.assist_type {

+ AssistType::Set => {

+ generate_setter_from_info(&assist_info, record_field_info, &syntax_factory)

+ }

+ _ => {

+ generate_getter_from_info(ctx, &assist_info, record_field_info, &syntax_factory)

+ }

+ };

+ let new_fn = method.clone_for_update();

+ let new_fn = new_fn.indent(1.into());

+ new_fn.into()

+ })

+ .collect();

+ if let Some(impl_def) = &assist_info.impl_def {

+ // We have an existing impl to add to

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

+ impl_def.assoc_item_list().unwrap().add_items(&mut editor, items.clone());

+ if let Some(cap) = ctx.config.snippet_cap

+ && let Some(ast::AssocItem::Fn(fn_)) = items.last()

+ && let Some(name) = fn_.name()

+ let tabstop = builder.make_tabstop_before(cap);

+ editor.add_annotation(name.syntax(), tabstop);

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

+ return;

+ let ty_params = assist_info.strukt.generic_param_list();

+ let ty_args = ty_params.as_ref().map(|it| it.to_generic_args());

+ let impl_def = syntax_factory.impl_(

+ None,

+ ty_params,

+ ty_args,

+ syntax_factory

+ .ty_path(syntax_factory.ident_path(&assist_info.strukt.name().unwrap().to_string()))

+ .into(),

+ None,

+ Some(syntax_factory.assoc_item_list(items)),

+ );

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

+ editor.insert_all(

+ Position::after(assist_info.strukt.syntax()),

+ vec![syntax_factory.whitespace("\n\n").into(), impl_def.syntax().clone().into()],

+ );

+

+ if let Some(cap) = ctx.config.snippet_cap

+ && let Some(assoc_list) = impl_def.assoc_item_list()

+ && let Some(ast::AssocItem::Fn(fn_)) = assoc_list.assoc_items().last()

+ && let Some(name) = fn_.name()

+ {

+ let tabstop = builder.make_tabstop_before(cap);

+ editor.add_annotation(name.syntax().clone(), tabstop);

+ }

+

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

+ ast::{self, AstNode, HasGenericParams, HasName, edit::AstNodeEdit, make},

+fn insert_impl(

+ editor: &mut SyntaxEditor,

+ impl_: &ast::Impl,

+ nominal: &impl AstNodeEdit,

+) -> ast::Impl {

+ let impl_ = impl_.indent(indent);

+

+ impl_

+

+ let impl_ = insert_impl(&mut editor, &impl_, &nominal);

+

+ let impl_ = insert_impl(&mut editor, &impl_, &nominal);

+ let impl_ = insert_impl(&mut editor, &impl_, &trait_);

+

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

+ let indent = impl_def.indent_level();

+ let new_impl = new_impl.indent(indent);

+ ast::{self, AstNode, HasName, HasVisibility, StructKind, edit::AstNodeEdit, make},

+ .clone_for_update()

+ .indent(1.into());

+ let fn_ = fn_.indent(impl_def.indent_level());

+ let impl_def = generate_impl_with_item(&ast::Adt::Struct(strukt.clone()), Some(list))

+ .indent(strukt.indent_level());

+ ast::{self, HasGenericParams, HasName, HasVisibility, edit::AstNodeEdit, make},

+ if !is_in_type_path(&self_tok)

+ && let Some(ty) = ast::Type::cast(replace_with.clone())

+ && let Some(generic_arg_list) = ty.generic_arg_list()

+ {

+ ted::remove(generic_arg_list.syntax());

+ }

+fn is_in_type_path(self_tok: &syntax::SyntaxToken) -> bool {

+ self_tok

+ .parent_ancestors()

+ .skip_while(|it| !ast::Path::can_cast(it.kind()))

+ .map_while(ast::Path::cast)

+ .last()

+ .and_then(|it| it.syntax().parent())

+ .and_then(ast::PathType::cast)

+ .is_some()

+}

+

+ fn inline_trait_method_call_with_lifetimes() {

+ check_assist(

+ inline_call,

+ r#"

+trait Trait {

+ fn f() -> Self;

+}

+struct Foo<'a>(&'a ());

+impl<'a> Trait for Foo<'a> {

+ fn f() -> Self { Self(&()) }

+}

+impl Foo<'_> {

+ fn new() -> Self {

+ Self::$0f()

+ }

+}

+"#,

+ r#"

+trait Trait {

+ fn f() -> Self;

+}

+struct Foo<'a>(&'a ());

+impl<'a> Trait for Foo<'a> {

+ fn f() -> Self { Self(&()) }

+}

+impl Foo<'_> {

+ fn new() -> Self {

+ Foo(&())

+ }

+}

+"#,

+ )

+ }

+

+ #[test]

+use ide_db::{FileId, FxHashSet};

+ AstNode, SmolStr, T, TextRange, ToSmolStr,

+ ast::{self, HasGenericParams, HasName, syntax_factory::SyntaxFactory},

+ format_smolstr,

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

+use crate::{AssistContext, AssistId, Assists};

+ let file_id = ctx.vfs_file_id();

+ generate_fn_def_assist(acc, fn_def, lifetime_loc, lifetime, file_id)

+ generate_impl_def_assist(acc, impl_def, lifetime_loc, lifetime, file_id)

+/// Given a type parameter list, generate a unique lifetime parameter name

+/// which is not in the list

+fn generate_unique_lifetime_param_name(

+ existing_params: Option<ast::GenericParamList>,

+) -> Option<SmolStr> {

+ let used_lifetime_param: FxHashSet<SmolStr> = existing_params

+ .iter()

+ .flat_map(|params| params.lifetime_params())

+ .map(|p| p.syntax().text().to_smolstr())

+ .collect();

+ ('a'..='z').map(|c| format_smolstr!("'{c}")).find(|lt| !used_lifetime_param.contains(lt))

+}

+

+ file_id: FileId,

+ let param_list = fn_def.param_list()?;

+ let new_lifetime_name = generate_unique_lifetime_param_name(fn_def.generic_param_list())?;

+

+ let unnamed_refs: Vec<_> = param_list

+ Some(ast::Type::RefType(ref_type)) if ref_type.lifetime().is_none() => {

+ Some(NeedsLifetime::RefType(ref_type))

+

+ match unnamed_refs.len() {

+ 1 => Some(unnamed_refs.into_iter().next()?),

+

+ acc.add(AssistId::refactor(ASSIST_NAME), ASSIST_LABEL, lifetime_loc, |edit| {

+ let root = fn_def.syntax().ancestors().last().unwrap().clone();

+ let mut editor = SyntaxEditor::new(root);

+ let factory = SyntaxFactory::with_mappings();

+

+ if let Some(generic_list) = fn_def.generic_param_list() {

+ insert_lifetime_param(&mut editor, &factory, &generic_list, &new_lifetime_name);

+ } else {

+ insert_new_generic_param_list_fn(&mut editor, &factory, &fn_def, &new_lifetime_name);

+

+ editor.replace(lifetime.syntax(), factory.lifetime(&new_lifetime_name).syntax());

+

+ if let Some(pos) = loc_needing_lifetime.and_then(|l| l.to_position()) {

+ editor.insert_all(

+ pos,

+ vec![

+ factory.lifetime(&new_lifetime_name).syntax().clone().into(),

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

+ ],

+ );

+ }

+

+ edit.add_file_edits(file_id, editor);

+fn insert_new_generic_param_list_fn(

+ editor: &mut SyntaxEditor,

+ factory: &SyntaxFactory,

+ fn_def: &ast::Fn,

+ lifetime_name: &str,

+ let name = fn_def.name()?;

+ editor.insert_all(

+ Position::after(name.syntax()),

+ vec![

+ factory.token(T![<]).syntax_element(),

+ factory.lifetime(lifetime_name).syntax().syntax_element(),

+ factory.token(T![>]).syntax_element(),

+ ],

+ );

+ Some(())

+fn generate_impl_def_assist(

+ acc: &mut Assists,

+ impl_def: ast::Impl,

+ lifetime_loc: TextRange,

+ lifetime: ast::Lifetime,

+ file_id: FileId,

+) -> Option<()> {

+ let new_lifetime_name = generate_unique_lifetime_param_name(impl_def.generic_param_list())?;

+

+ acc.add(AssistId::refactor(ASSIST_NAME), ASSIST_LABEL, lifetime_loc, |edit| {

+ let root = impl_def.syntax().ancestors().last().unwrap().clone();

+ let mut editor = SyntaxEditor::new(root);

+ let factory = SyntaxFactory::without_mappings();

+

+ if let Some(generic_list) = impl_def.generic_param_list() {

+ insert_lifetime_param(&mut editor, &factory, &generic_list, &new_lifetime_name);

+ } else {

+ insert_new_generic_param_list_imp(&mut editor, &factory, &impl_def, &new_lifetime_name);

+ }

+

+ editor.replace(lifetime.syntax(), factory.lifetime(&new_lifetime_name).syntax());

+

+ edit.add_file_edits(file_id, editor);

+ })

+}

+

+fn insert_new_generic_param_list_imp(

+ editor: &mut SyntaxEditor,

+ factory: &SyntaxFactory,

+ impl_: &ast::Impl,

+ lifetime_name: &str,

+) -> Option<()> {

+ let impl_kw = impl_.impl_token()?;

+

+ editor.insert_all(

+ Position::after(impl_kw),

+ vec![

+ factory.token(T![<]).syntax_element(),

+ factory.lifetime(lifetime_name).syntax().syntax_element(),

+ factory.token(T![>]).syntax_element(),

+ ],

+ );

+

+ Some(())

+}

+

+fn insert_lifetime_param(

+ editor: &mut SyntaxEditor,

+ factory: &SyntaxFactory,

+ generic_list: &ast::GenericParamList,

+ lifetime_name: &str,

+) -> Option<()> {

+ let r_angle = generic_list.r_angle_token()?;

+ let needs_comma = generic_list.generic_params().next().is_some();

+

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

+

+ if needs_comma {

+ elements.push(factory.token(T![,]).syntax_element());

+ elements.push(factory.whitespace(" ").syntax_element());

+ }

+

+ let lifetime = factory.lifetime(lifetime_name);

+ elements.push(lifetime.syntax().clone().into());

+

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

+ Some(())

+}

+

+ ast::{

+ self, AstNode,

+ edit::{AstNodeEdit, IndentLevel},

+ },

+ let const_ = const_.reset_indent();

+ let const_ = const_.indent(indent);

+ fn add_custom_impl_clone_generic_tuple_struct_with_associated() {

+ check_assist(

+ replace_derive_with_manual_impl,

+ r#"

+//- minicore: clone, derive, deref

+#[derive(Clo$0ne)]

+struct Foo<T: core::ops::Deref>(T::Target);

+"#,

+ r#"

+struct Foo<T: core::ops::Deref>(T::Target);

+

+impl<T: core::ops::Deref + Clone> Clone for Foo<T>

+where T::Target: Clone

+{

+ $0fn clone(&self) -> Self {

+ Self(self.0.clone())

+ }

+}

+"#,

+ )

+ }

+

+ #[test]

+ ast::{

+ self, HasName,

+ edit::{AstNodeEdit, IndentLevel},

+ syntax_factory::SyntaxFactory,

+ },

+ else_block = Some(block.reset_indent().indent(IndentLevel(1)));

+ let guard = if let Some(guard) = &guard {

+ Some(guard.dedent(indent).indent(IndentLevel(1)))

+ } else {

+ guard

+ };

+

+ let body = if_expr.then_branch()?.clone_for_update().indent(IndentLevel(1));

+ // Dedent from original position, then indent for match arm

+ let body = body.dedent(indent).indent(IndentLevel::single());

+ let match_expr =

+ make.expr_match(scrutinee_to_be_expr, make.match_arm_list(arms)).indent(indent);

+ let block_expr = make

+ .block_expr([], Some(match_expr.dedent(indent).indent(IndentLevel(1))))

+ .indent(indent);

+ expr => make.block_expr([], Some(expr.indent(IndentLevel(1)))),

+ let then_expr =

+ then_expr.clone_for_update().reset_indent().indent(IndentLevel::single());

+ let else_expr =

+ else_expr.clone_for_update().reset_indent().indent(IndentLevel::single());

+ let if_let_expr = make

+ .expr_if(

+ condition,

+ then_block,

+ else_expr.map(make_block_expr).map(ast::ElseBranch::Block),

+ )

+ .indent(IndentLevel::from_node(match_expr.syntax()));

+ ast::{

+ self,

+ edit::{AstNodeEdit, IndentLevel},

+ syntax_factory::SyntaxFactory,

+ },

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

+use itertools::Itertools;

+ let adt_assoc_bounds = trait_

+ .as_ref()

+ .zip(generic_params.as_ref())

+ .and_then(|(trait_, params)| generic_param_associated_bounds(adt, trait_, params));

+

+ adt_assoc_bounds,

+fn generic_param_associated_bounds(

+ adt: &ast::Adt,

+ trait_: &ast::Type,

+ generic_params: &ast::GenericParamList,

+) -> Option<ast::WhereClause> {

+ let in_type_params = |name: &ast::NameRef| {

+ generic_params

+ .generic_params()

+ .filter_map(|param| match param {

+ ast::GenericParam::TypeParam(type_param) => type_param.name(),

+ _ => None,

+ })

+ .any(|param| param.text() == name.text())

+ };

+ let adt_body = match adt {

+ ast::Adt::Enum(e) => e.variant_list().map(|it| it.syntax().clone()),

+ ast::Adt::Struct(s) => s.field_list().map(|it| it.syntax().clone()),

+ ast::Adt::Union(u) => u.record_field_list().map(|it| it.syntax().clone()),

+ };

+ let mut trait_where_clause = adt_body

+ .into_iter()

+ .flat_map(|it| it.descendants())

+ .filter_map(ast::Path::cast)

+ .filter_map(|path| {

+ let qualifier = path.qualifier()?.as_single_segment()?;

+ let qualifier = qualifier

+ .name_ref()

+ .or_else(|| match qualifier.type_anchor()?.ty()? {

+ ast::Type::PathType(path_type) => path_type.path()?.as_single_name_ref(),

+ _ => None,

+ })

+ .filter(in_type_params)?;

+ Some((qualifier, path.segment()?.name_ref()?))

+ })

+ .map(|(qualifier, assoc_name)| {

+ let segments = [qualifier, assoc_name].map(make::path_segment);

+ let path = make::path_from_segments(segments, false);

+ let bounds = Some(make::type_bound(trait_.clone()));

+ make::where_pred(either::Either::Right(make::ty_path(path)), bounds)

+ })

+ .unique_by(|it| it.syntax().to_string())

+ .peekable();

+ trait_where_clause.peek().is_some().then(|| make::where_clause(trait_where_clause))

+}

+

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

+

+ pub(crate) fn wrap_expr_with_factory(

+ &self,

+ mut expr: ast::Expr,

+ syntax_factory: &SyntaxFactory,

+ ) -> ast::Expr {

+ if self.needs_deref {

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

+ }

+

+ if self.needs_parentheses {

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

+ }

+

+ expr

+ }

+ matches!(

+ node.kind(),

+ BLOCK_EXPR | MATCH_ARM | CLOSURE_EXPR | ARG_LIST | PAREN_EXPR | ARRAY_EXPR

+ )

+

+ #[test]

+ fn no_semicolon_in_array() {

+ check_edit(

+ r#"foo"#,

+ r#"

+fn foo() {}

+fn bar() {

+ let _ = [fo$0];

+}

+"#,

+ r#"

+fn foo() {}

+fn bar() {

+ let _ = [foo()$0];

+}

+"#,

+ );

+ }

+use smallvec::{SmallVec, smallvec};

+ /// Potentially more segments that should resolve in the candidate.

+ pub after: Vec<Name>,

+ let mut result = match &*path_candidate.qualifier {

+ };

+

+ filter_candidates_by_after_path(db, scope, path_candidate, &mut result);

+

+ result

+}

+

+fn filter_candidates_by_after_path(

+ db: &RootDatabase,

+ scope: &SemanticsScope<'_>,

+ path_candidate: &PathImportCandidate,

+ imports: &mut FxIndexSet<LocatedImport>,

+) {

+ if imports.len() <= 1 {

+ // Short-circuit, as even if it doesn't match fully we want it.

+ return;

+ }

+

+ let Some((last_after, after_except_last)) = path_candidate.after.split_last() else {

+ return;

+ };

+

+ let original_imports = imports.clone();

+

+ let traits_in_scope = scope.visible_traits();

+ imports.retain(|import| {

+ let items = if after_except_last.is_empty() {

+ smallvec![import.original_item]

+ } else {

+ let ItemInNs::Types(ModuleDef::Module(item)) = import.original_item else {

+ return false;

+ };

+ // FIXME: This doesn't consider visibilities.

+ item.resolve_mod_path(db, after_except_last.iter().cloned())

+ .into_iter()

+ .flatten()

+ .collect::<SmallVec<[_; 3]>>()

+ };

+ items.into_iter().any(|item| {

+ let has_last_method = |ty: hir::Type<'_>| {

+ ty.iterate_path_candidates(db, scope, &traits_in_scope, Some(last_after), |_| {

+ Some(())

+ })

+ .is_some()

+ };

+ // FIXME: A trait can have an assoc type that has a function/const, that's two segments before last.

+ match item {

+ // A module? Can we resolve one more segment?

+ ItemInNs::Types(ModuleDef::Module(module)) => module

+ .resolve_mod_path(db, [last_after.clone()])

+ .is_some_and(|mut it| it.any(|_| true)),

+ // And ADT/Type Alias? That might be a method.

+ ItemInNs::Types(ModuleDef::Adt(it)) => has_last_method(it.ty(db)),

+ ItemInNs::Types(ModuleDef::BuiltinType(it)) => has_last_method(it.ty(db)),

+ ItemInNs::Types(ModuleDef::TypeAlias(it)) => has_last_method(it.ty(db)),

+ // A trait? Might have an associated item.

+ ItemInNs::Types(ModuleDef::Trait(it)) => it

+ .items(db)

+ .into_iter()

+ .any(|assoc_item| assoc_item.name(db) == Some(last_after.clone())),

+ // Other items? can't resolve one more segment.

+ _ => false,

+ }

+ })

+ });

+

+ if imports.is_empty() {

+ // Better one half-match than zero full matches.

+ *imports = original_imports;

+ let after = std::iter::successors(path.parent_path(), |it| it.parent_path())

+ .map(|seg| seg.segment()?.name_ref().map(|name| Name::new_root(&name.text())))

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

+ after,

+ after: vec![],

+ // Assume a fuzzy match does not want the segments after. Because... I guess why not?

+ path_import_candidate(sema, qualifier, NameToImport::fuzzy(fuzzy_name), Vec::new())

+ after: Vec<Name>,

+ ImportCandidate::Path(PathImportCandidate { qualifier, name, after })

+ None => ImportCandidate::Path(PathImportCandidate { qualifier: vec![], name, after }),

+ edit_in_place::Removable, make, syntax_factory::SyntaxFactory,

+ syntax_editor::{Position, SyntaxEditor},

+/// Insert an import path into the given file/node. A `merge` value of none indicates that no import merging is allowed to occur.

+pub fn insert_use_with_editor(

+ scope: &ImportScope,

+ path: ast::Path,

+ cfg: &InsertUseConfig,

+ syntax_editor: &mut SyntaxEditor,

+ syntax_factory: &SyntaxFactory,

+) {

+ insert_use_with_alias_option_with_editor(scope, path, cfg, None, syntax_editor, syntax_factory);

+}

+

+fn insert_use_with_alias_option_with_editor(

+ scope: &ImportScope,

+ path: ast::Path,

+ cfg: &InsertUseConfig,

+ alias: Option<ast::Rename>,

+ syntax_editor: &mut SyntaxEditor,

+ syntax_factory: &SyntaxFactory,

+) {

+ let _p = tracing::info_span!("insert_use_with_alias_option").entered();

+ let mut mb = match cfg.granularity {

+ ImportGranularity::Crate => Some(MergeBehavior::Crate),

+ ImportGranularity::Module => Some(MergeBehavior::Module),

+ ImportGranularity::One => Some(MergeBehavior::One),

+ ImportGranularity::Item => None,

+ };

+ if !cfg.enforce_granularity {

+ let file_granularity = guess_granularity_from_scope(scope);

+ mb = match file_granularity {

+ ImportGranularityGuess::Unknown => mb,

+ ImportGranularityGuess::Item => None,

+ ImportGranularityGuess::Module => Some(MergeBehavior::Module),

+ // We use the user's setting to infer if this is module or item.

+ ImportGranularityGuess::ModuleOrItem => match mb {

+ Some(MergeBehavior::Module) | None => mb,

+ // There isn't really a way to decide between module or item here, so we just pick one.

+ // FIXME: Maybe it is possible to infer based on semantic analysis?

+ Some(MergeBehavior::One | MergeBehavior::Crate) => Some(MergeBehavior::Module),

+ },

+ ImportGranularityGuess::Crate => Some(MergeBehavior::Crate),

+ ImportGranularityGuess::CrateOrModule => match mb {

+ Some(MergeBehavior::Crate | MergeBehavior::Module) => mb,

+ Some(MergeBehavior::One) | None => Some(MergeBehavior::Crate),

+ },

+ ImportGranularityGuess::One => Some(MergeBehavior::One),

+ };

+ }

+

+ let use_tree = syntax_factory.use_tree(path, None, alias, false);

+ if mb == Some(MergeBehavior::One) && use_tree.path().is_some() {

+ use_tree.wrap_in_tree_list();

+ }

+ let use_item = make::use_(None, None, use_tree).clone_for_update();

+ for attr in

+ scope.required_cfgs.iter().map(|attr| attr.syntax().clone_subtree().clone_for_update())

+ {

+ syntax_editor.insert(Position::first_child_of(use_item.syntax()), attr);

+ }

+

+ // merge into existing imports if possible

+ if let Some(mb) = mb {

+ let filter = |it: &_| !(cfg.skip_glob_imports && ast::Use::is_simple_glob(it));

+ for existing_use in

+ scope.as_syntax_node().children().filter_map(ast::Use::cast).filter(filter)

+ {

+ if let Some(merged) = try_merge_imports(&existing_use, &use_item, mb) {

+ syntax_editor.replace(existing_use.syntax(), merged.syntax());

+ return;

+ }

+ }

+ }

+ // either we weren't allowed to merge or there is no import that fits the merge conditions

+ // so look for the place we have to insert to

+ insert_use_with_editor_(scope, use_item, cfg.group, syntax_editor, syntax_factory);

+}

+

+fn insert_use_with_editor_(

+ scope: &ImportScope,

+ use_item: ast::Use,

+ group_imports: bool,

+ syntax_editor: &mut SyntaxEditor,

+ syntax_factory: &SyntaxFactory,

+) {

+ let scope_syntax = scope.as_syntax_node();

+ let insert_use_tree =

+ use_item.use_tree().expect("`use_item` should have a use tree for `insert_path`");

+ let group = ImportGroup::new(&insert_use_tree);

+ let path_node_iter = scope_syntax

+ .children()

+ .filter_map(|node| ast::Use::cast(node.clone()).zip(Some(node)))

+ .flat_map(|(use_, node)| {

+ let tree = use_.use_tree()?;

+ Some((tree, node))

+ });

+

+ if group_imports {

+ // Iterator that discards anything that's not in the required grouping

+ // This implementation allows the user to rearrange their import groups as this only takes the first group that fits

+ let group_iter = path_node_iter

+ .clone()

+ .skip_while(|(use_tree, ..)| ImportGroup::new(use_tree) != group)

+ .take_while(|(use_tree, ..)| ImportGroup::new(use_tree) == group);

+

+ // track the last element we iterated over, if this is still None after the iteration then that means we never iterated in the first place

+ let mut last = None;

+ // find the element that would come directly after our new import

+ let post_insert: Option<(_, SyntaxNode)> = group_iter

+ .inspect(|(.., node)| last = Some(node.clone()))

+ .find(|(use_tree, _)| use_tree_cmp(&insert_use_tree, use_tree) != Ordering::Greater);

+

+ if let Some((.., node)) = post_insert {

+ cov_mark::hit!(insert_group);

+ // insert our import before that element

+ return syntax_editor.insert(Position::before(node), use_item.syntax());

+ }

+ if let Some(node) = last {

+ cov_mark::hit!(insert_group_last);

+ // there is no element after our new import, so append it to the end of the group

+ return syntax_editor.insert(Position::after(node), use_item.syntax());

+ }

+

+ // the group we were looking for actually doesn't exist, so insert

+

+ let mut last = None;

+ // find the group that comes after where we want to insert

+ let post_group = path_node_iter

+ .inspect(|(.., node)| last = Some(node.clone()))

+ .find(|(use_tree, ..)| ImportGroup::new(use_tree) > group);

+ if let Some((.., node)) = post_group {

+ cov_mark::hit!(insert_group_new_group);

+ syntax_editor.insert(Position::before(&node), use_item.syntax());

+ if let Some(node) = algo::non_trivia_sibling(node.into(), Direction::Prev) {

+ syntax_editor.insert(Position::after(node), syntax_factory.whitespace("\n"));

+ }

+ return;

+ }

+ // there is no such group, so append after the last one

+ if let Some(node) = last {

+ cov_mark::hit!(insert_group_no_group);

+ syntax_editor.insert(Position::after(&node), use_item.syntax());

+ syntax_editor.insert(Position::after(node), syntax_factory.whitespace("\n"));

+ return;

+ }

+ } else {

+ // There exists a group, so append to the end of it

+ if let Some((_, node)) = path_node_iter.last() {

+ cov_mark::hit!(insert_no_grouping_last);

+ syntax_editor.insert(Position::after(node), use_item.syntax());

+ return;

+ }

+ }

+

+ let l_curly = match &scope.kind {

+ ImportScopeKind::File(_) => None,

+ // don't insert the imports before the item list/block expr's opening curly brace

+ ImportScopeKind::Module(item_list) => item_list.l_curly_token(),

+ // don't insert the imports before the item list's opening curly brace

+ ImportScopeKind::Block(block) => block.l_curly_token(),

+ };

+ // there are no imports in this file at all

+ // so put the import after all inner module attributes and possible license header comments

+ if let Some(last_inner_element) = scope_syntax

+ .children_with_tokens()

+ // skip the curly brace

+ .skip(l_curly.is_some() as usize)

+ .take_while(|child| match child {

+ NodeOrToken::Node(node) => is_inner_attribute(node.clone()),

+ NodeOrToken::Token(token) => {

+ [SyntaxKind::WHITESPACE, SyntaxKind::COMMENT, SyntaxKind::SHEBANG]

+ .contains(&token.kind())

+ }

+ })

+ .filter(|child| child.as_token().is_none_or(|t| t.kind() != SyntaxKind::WHITESPACE))

+ .last()

+ {

+ cov_mark::hit!(insert_empty_inner_attr);

+ syntax_editor.insert(Position::after(&last_inner_element), use_item.syntax());

+ syntax_editor.insert(Position::after(last_inner_element), syntax_factory.whitespace("\n"));

+ } else {

+ match l_curly {

+ Some(b) => {

+ cov_mark::hit!(insert_empty_module);

+ syntax_editor.insert(Position::after(&b), syntax_factory.whitespace("\n"));

+ syntax_editor.insert(Position::after(&b), use_item.syntax());

+ }

+ None => {

+ cov_mark::hit!(insert_empty_file);

+ syntax_editor.insert(

+ Position::first_child_of(scope_syntax),

+ syntax_factory.whitespace("\n\n"),

+ );

+ syntax_editor.insert(Position::first_child_of(scope_syntax), use_item.syntax());

+ }

+ }

+ }

+}

+

+fn test_hover_function_with_too_long_param() {

+ check(

+ r#"

+fn fn_$0(

+ attrs: impl IntoIterator<Item = ast::Attr>,

+ visibility: Option<ast::Visibility>,

+ fn_name: ast::Name,

+ type_params: Option<ast::GenericParamList>,

+ where_clause: Option<ast::WhereClause>,

+ params: ast::ParamList,

+ body: ast::BlockExpr,

+ ret_type: Option<ast::RetType>,

+ is_async: bool,

+ is_const: bool,

+ is_unsafe: bool,

+ is_gen: bool,

+) -> ast::Fn {}

+ "#,

+ expect![[r#"

+ *fn_*

+

+ ```rust

+ ra_test_fixture

+ ```

+

+ ```rust

+ fn fn_(

+ attrs: impl IntoIterator<Item = ast::Attr>,

+ visibility: Option<ast::Visibility>,

+ fn_name: ast::Name,

+ type_params: Option<ast::GenericParamList>,

+ where_clause: Option<ast::WhereClause>,

+ params: ast::ParamList,

+ body: ast::BlockExpr,

+ ret_type: Option<ast::RetType>,

+ is_async: bool,

+ is_const: bool,

+ is_unsafe: bool,

+ is_gen: bool

+ ) -> ast::Fn

+ ```

+ "#]],

+ );

+

+ check(

+ r#"

+fn fn_$0(

+ &self,

+ attrs: impl IntoIterator<Item = ast::Attr>,

+ visibility: Option<ast::Visibility>,

+ fn_name: ast::Name,

+ type_params: Option<ast::GenericParamList>,

+ where_clause: Option<ast::WhereClause>,

+ params: ast::ParamList,

+ body: ast::BlockExpr,

+ ret_type: Option<ast::RetType>,

+ is_async: bool,

+ is_const: bool,

+ is_unsafe: bool,

+ is_gen: bool,

+ ...

+) -> ast::Fn {}

+ "#,

+ expect![[r#"

+ *fn_*

+

+ ```rust

+ ra_test_fixture

+ ```

+

+ ```rust

+ fn fn_(

+ &self,

+ attrs: impl IntoIterator<Item = ast::Attr>,

+ visibility: Option<ast::Visibility>,

+ fn_name: ast::Name,

+ type_params: Option<ast::GenericParamList>,

+ where_clause: Option<ast::WhereClause>,

+ params: ast::ParamList,

+ body: ast::BlockExpr,

+ ret_type: Option<ast::RetType>,

+ is_async: bool,

+ is_const: bool,

+ is_unsafe: bool,

+ is_gen: bool,

+ ...

+ ) -> ast::Fn

+ ```

+ "#]],

+ );

+}

+

+#[test]

+ salsa::{Cancelled, Database},

+ FileId(0) 17..25 import

+ FileId(0) 17..23 import

+<pre><code><span class="keyword">use</span> <span class="crate_root library">proc_macros</span><span class="operator">::</span><span class="brace">{</span><span class="proc_macro library">mirror</span><span class="comma">,</span> <span class="attribute library">identity</span><span class="comma">,</span> <span class="derive library">DeriveIdentity</span><span class="brace">}</span><span class="semicolon">;</span>

+<span class="keyword">use</span> <span class="crate_root library">pm</span><span class="operator">::</span><span class="attribute library">proc_macro</span><span class="semicolon">;</span>

+//- /lib.rs crate:lib deps:pm

+use pm::proc_macro;

+//- /pm.rs crate:pm

+#![crate_type = "proc-macro"]

+

+#[proc_macro_attribute]

+pub fn proc_macro() {}

+ bidirectional_protocol::msg::{SubRequest, SubResponse},

+ let vec = server.load_dylib(dylib).map_err(|e| {

+rayon.workspace = true

+ pub fn load_dylib(&self, dylib: MacroDylib) -> Result<Vec<ProcMacro>, ServerError> {

+ self.pool.load_dylib(&dylib)

+use rayon::iter::{IntoParallelIterator, ParallelIterator};

+

+use crate::{MacroDylib, ProcMacro, ServerError, process::ProcMacroServerProcess};

+ pub(crate) fn load_dylib(&self, dylib: &MacroDylib) -> Result<Vec<ProcMacro>, ServerError> {

+ .find_proc_macros(&dylib.path)?

+ rest.into_par_iter()

+ .map(|worker| {

+ worker

+ .find_proc_macros(&dylib.path)?

+ .map(|_| ())

+ .map_err(|e| ServerError { message: e, io: None })

+ })

+ .collect::<Result<(), _>>()?;

+ bidirectional_protocol::{

+ self, SubCallback,

+ msg::{BidirectionalMessage, SubResponse},

+ reject_subrequests,

+ },

+ bidirectional_protocol::find_proc_macros(self, dylib_path, &|_| {

+ Ok(SubResponse::Cancel {

+ reason: String::from(

+ "Server should not do a sub request when loading proc-macros",

+ ),

+ })

+ })

+ if self.diagnostics_received == DiagnosticsReceived::NotYet {

+ self.diagnostics_received = DiagnosticsReceived::AtLeastOne;

+ }

+ if let Some(package_id) = &package_id {

+ if self.diagnostics_cleared_for.insert(package_id.clone()) {

+ tracing::trace!(

+ flycheck_id = self.id,

+ package_id = package_id.as_str(),

+ "clearing diagnostics"

+ );

+ self.send(FlycheckMessage::ClearDiagnostics {

+ kind: ClearDiagnosticsKind::All(ClearScope::Package(

+ package_id.clone(),

+ )),

+ } else if self.diagnostics_received

+ != DiagnosticsReceived::AtLeastOneAndClearedWorkspace

+ {

+ self.diagnostics_received =

+ DiagnosticsReceived::AtLeastOneAndClearedWorkspace;

+ self.send(FlycheckMessage::ClearDiagnostics {

+ id: self.id,

+ kind: ClearDiagnosticsKind::All(ClearScope::Workspace),

+ });

+ self.send(FlycheckMessage::AddDiagnostic {

+ id: self.id,

+ generation: self.generation,

+ package_id,

+ workspace_root: self.root.clone(),

+ diagnostic,

+ });

+ base_db::{Crate, ProcMacroPaths, SourceDatabase, salsa::Revision},

+ Err(_cancelled) if ALLOW_RETRYING => Task::Retry(req),

+ impl<'db, T0, T1, T2, T3> zalsa_::interned::HashEqLike<StructKey<'db, T0, T1, T2, T3>>

+ for SyntaxContextData

+ Option<MacroCallId>: zalsa_::interned::HashEqLike<T0>,

+ Transparency: zalsa_::interned::HashEqLike<T1>,

+ Edition: zalsa_::interned::HashEqLike<T2>,

+ SyntaxContext: zalsa_::interned::HashEqLike<T3>,

+ zalsa_::interned::HashEqLike::<T0>::hash(&self.outer_expn, &mut *h);

+ zalsa_::interned::HashEqLike::<T1>::hash(&self.outer_transparency, &mut *h);

+ zalsa_::interned::HashEqLike::<T2>::hash(&self.edition, &mut *h);

+ zalsa_::interned::HashEqLike::<T3>::hash(&self.parent, &mut *h);

+ zalsa_::interned::HashEqLike::<T0>::eq(&self.outer_expn, &data.0)

+ && zalsa_::interned::HashEqLike::<T1>::eq(&self.outer_transparency, &data.1)

+ && zalsa_::interned::HashEqLike::<T2>::eq(&self.edition, &data.2)

+ && zalsa_::interned::HashEqLike::<T3>::eq(&self.parent, &data.3)

+ T0: zalsa_::interned::Lookup<Option<MacroCallId>> + std::hash::Hash,

+ T1: zalsa_::interned::Lookup<Transparency> + std::hash::Hash,

+ T2: zalsa_::interned::Lookup<Edition> + std::hash::Hash,

+ T3: zalsa_::interned::Lookup<SyntaxContext> + std::hash::Hash,

+ Option<MacroCallId>: zalsa_::interned::HashEqLike<T0>,

+ Transparency: zalsa_::interned::HashEqLike<T1>,

+ Edition: zalsa_::interned::HashEqLike<T2>,

+ SyntaxContext: zalsa_::interned::HashEqLike<T3>,

+ outer_expn: zalsa_::interned::Lookup::into_owned(data.0),

+ outer_transparency: zalsa_::interned::Lookup::into_owned(data.1),

+ edition: zalsa_::interned::Lookup::into_owned(data.2),

+ parent: zalsa_::interned::Lookup::into_owned(data.3),

+ ast::{self, HasGenericParams, edit::IndentLevel, make, syntax_factory::SyntaxFactory},

+ syntax_editor::{Position, SyntaxEditor},

+ ted,

+ ted::Position::after(name.syntax)

+ ted::Position::after(fn_token)

+ ted::Position::before(param_list.syntax)

+ ted::Position::last_child_of(self.syntax())

+ ted::Position::after(ty.syntax())

+ ted::Position::after(param_list.syntax())

+ ted::Position::last_child_of(self.syntax())

+ Some(imp_token) => ted::Position::after(imp_token),

+ None => ted::Position::last_child_of(self.syntax()),

+ Some(items) => ted::Position::before(items.syntax()),

+ None => ted::Position::last_child_of(self.syntax()),

+ ted::Position::after(name.syntax)

+ ted::Position::after(trait_token)

+ ted::Position::last_child_of(self.syntax())

+ (Some(items), _) => ted::Position::before(items.syntax()),

+ (_, Some(tok)) => ted::Position::before(tok),

+ (None, None) => ted::Position::last_child_of(self.syntax()),

+ ted::Position::after(name.syntax)

+ ted::Position::after(trait_token)

+ ted::Position::last_child_of(self.syntax())

+ Some(tok) => ted::Position::before(tok),

+ Some(tok) => ted::Position::before(tok),

+ None => ted::Position::last_child_of(self.syntax()),

+ ted::Position::after(name.syntax)

+ ted::Position::after(struct_token)

+ ted::Position::last_child_of(self.syntax())

+ ted::Position::after(tfl.syntax())

+ ted::Position::after(gpl.syntax())

+ ted::Position::after(name.syntax())

+ ted::Position::last_child_of(self.syntax())

+ ted::Position::after(name.syntax)

+ ted::Position::after(enum_token)

+ ted::Position::last_child_of(self.syntax())

+ ted::Position::after(gpl.syntax())

+ ted::Position::after(name.syntax())

+ ted::Position::last_child_of(self.syntax())

+fn create_where_clause(position: ted::Position) {

+fn create_generic_param_list(position: ted::Position) -> ast::GenericParamList {

+ let position = ted::Position::after(last_param.syntax());

+ let after_l_angle = ted::Position::after(self.l_angle_token().unwrap());

+ let position = ted::Position::last_child_of(self.syntax());

+ ted::insert(ted::Position::first_child_of(self.syntax()), prefix.syntax());

+ ted::Position::after(last_tree.syntax()),

+ Some(l_curly) => ted::Position::after(l_curly),

+ None => ted::Position::last_child_of(self.syntax()),

+ ted::Position::after(last_item.syntax()),

+ (IndentLevel::from_token(&l_curly) + 1, ted::Position::after(&l_curly), "\n")

+ None => (IndentLevel::single(), ted::Position::last_child_of(self.syntax()), "\n"),

+ ted::Position::after(comma)

+ Some(it) => ted::Position::after(it),

+ None => ted::Position::last_child_of(self.syntax()),

+ ted::insert(ted::Position::after(field.syntax()), ast::make::token(T![,]));

+ ted::insert_all_raw(ted::Position::last_child_of(self.syntax()), children);

+ ted::Position::after(comma)

+ Some(it) => ted::Position::after(it),

+ None => ted::Position::last_child_of(self.syntax()),

+ ted::insert(ted::Position::after(field.syntax()), ast::make::token(T![,]));

+ ted::insert(ted::Position::after(syntax), &comma);

+ ted::insert(ted::Position::after(l), make::tokens::whitespace(&format!("\n{indent}")));

+

+ pub fn set_pat_with_editor(

+ &self,

+ pat: Option<ast::Pat>,

+ syntax_editor: &mut SyntaxEditor,

+ syntax_factory: &SyntaxFactory,

+ ) {

+ match pat {

+ None => {

+ if let Some(at_token) = self.at_token() {

+ // Remove `@ Pat`

+ let start = at_token.clone().into();

+ let end = self

+ .pat()

+ .map(|it| it.syntax().clone().into())

+ .unwrap_or_else(|| at_token.into());

+ syntax_editor.delete_all(start..=end);

+

+ // Remove any trailing ws

+ if let Some(last) =

+ self.syntax().last_token().filter(|it| it.kind() == WHITESPACE)

+ {

+ last.detach();

+ }

+ }

+ }

+ Some(pat) => {

+ if let Some(old_pat) = self.pat() {

+ // Replace existing pattern

+ syntax_editor.replace(old_pat.syntax(), pat.syntax())

+ } else if let Some(at_token) = self.at_token() {

+ // Have an `@` token but not a pattern yet

+ syntax_editor.insert(Position::after(at_token), pat.syntax());

+ } else {

+ // Don't have an `@`, should have a name

+ let name = self.name().unwrap();

+

+ syntax_editor.insert_all(

+ Position::after(name.syntax()),

+ vec![

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

+ syntax_factory.token(T![@]).into(),

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

+ pat.syntax().clone().into(),

+ ],

+ )

+ }

+ }

+ }

+ }

+ pub fn path_concat(&self, first: ast::Path, second: ast::Path) -> ast::Path {

+ make::path_concat(first, second).clone_for_update()

+ }

+

+ pub fn visibility_pub(&self) -> ast::Visibility {

+ make::visibility_pub()

+ }

+

+ pub fn struct_(

+ &self,

+ visibility: Option<ast::Visibility>,

+ strukt_name: ast::Name,

+ generic_param_list: Option<ast::GenericParamList>,

+ field_list: ast::FieldList,

+ ) -> ast::Struct {

+ make::struct_(visibility, strukt_name, generic_param_list, field_list).clone_for_update()

+ }

+

+ pub fn self_param(&self) -> ast::SelfParam {

+ let ast = make::self_param().clone_for_update();

+

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

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

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ }

+

+ pub fn impl_(

+ &self,

+ attrs: impl IntoIterator<Item = ast::Attr>,

+ generic_params: Option<ast::GenericParamList>,

+ generic_args: Option<ast::GenericArgList>,

+ path_type: ast::Type,

+ where_clause: Option<ast::WhereClause>,

+ body: Option<ast::AssocItemList>,

+ ) -> ast::Impl {

+ let (attrs, attrs_input) = iterator_input(attrs);

+ let ast = make::impl_(

+ attrs,

+ generic_params.clone(),

+ generic_args.clone(),

+ path_type.clone(),

+ where_clause.clone(),

+ body.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(generic_params) = generic_params {

+ builder.map_node(

+ generic_params.syntax().clone(),

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

+ );

+ }

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

+ if let Some(where_clause) = where_clause {

+ builder.map_node(

+ where_clause.syntax().clone(),

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

+ );

+ }

+ if let Some(body) = body {

+ builder.map_node(

+ body.syntax().clone(),

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

+ );

+ }

+ builder.finish(&mut mapping);

+ }

+

+ ast

+ }

+

+ pub struct Filter<I, P> {

+ iter: I,

+ predicate: P,

+ }

+ impl<I: Iterator, P> Iterator for Filter<I, P>

+ where

+ P: FnMut(&I::Item) -> bool,

+ {

+ type Item = I::Item;

+

+ fn next(&mut self) -> Option<I::Item> {

+ loop {}

+ }

+ }

+

+ pub use self::adapters::{Filter, FilterMap, Take};

+ fn filter<P>(self, predicate: P) -> crate::iter::Filter<Self, P>

+ where

+ Self: Sized,

+ P: FnMut(&Self::Item) -> bool,

+ {

+ loop {}

+ }

+ *close_span = S::new(span.close.range, 1);

+ "version": "6.14.2",

+ "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.2.tgz",

+ "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==",

+ let vec = u8::vec_from_reader(len, reader)?.ok_or_else(|| {

+ Error::new(ErrorKind::Other, "u8::vec_from_reader unexpectedly returned None")

+ })?;

+#[cfg(all(feature = "borsh", feature = "std"))]

+139651428df86cf88443295542c12ea617cbb587