+

+**repository link (if public, optional)**: (eg. [rust-analyzer](https://github.com/rust-lang/rust-analyzer))

+

+**code snippet to reproduce**:

+```rust

+// add your code here

+

+```

+[files]

+extend-exclude = [

+ "*.rast",

+ "bench_data/",

+ "crates/parser/test_data/lexer/err/",

+ "crates/project-model/test_data/",

+]

+ignore-hidden = false

+

+[default]

+extend-ignore-re = [

+ # ignore string which contains $0, which is used widely in tests

+ ".*\\$0.*",

+ # ignore generated content like `boxed....nner()`, `Defaul...efault`

+ "\\w*\\.{3,4}\\w*",

+ '"flate2"',

+ "raison d'être",

+]

+[default.extend-identifiers]

+datas = "datas"

+impl_froms = "impl_froms"

+selfs = "selfs"

+ "crossbeam-channel",

+ "hashbrown",

+ "rustc-hash",

+rust-version = "1.76"

+[profile.dev-rel]

+inherits = "release"

+debug = 2

+

+ .find_map(|(id, data)| merge((id, data), (topo, crate_data)).then_some(id));

+ .name("CommandHandle".to_owned())

+use span::AstIdMap;

+fn macro_exported_in_block_mod() {

+ check_at(

+ r#"

+#[macro_export]

+macro_rules! foo {

+ () => { pub struct FooWorks; };

+}

+macro_rules! bar {

+ () => { pub struct BarWorks; };

+}

+fn main() {

+ mod module {

+ foo!();

+ bar!();

+ $0

+ }

+}

+"#,

+ expect![[r#"

+ block scope

+ module: t

+

+ block scope::module

+ BarWorks: t v

+ FooWorks: t v

+

+ crate

+ foo: m

+ main: v

+ "#]],

+ );

+}

+

+#[test]

+ for (block, def_map) in body.blocks(db) {

+ res[keys::BLOCK].insert(block.lookup(db).ast_id.to_node(db.upcast()), block);

+ BlockId, ConstId, EnumId, EnumVariantId, ExternCrateId, FieldId, FunctionId, ImplId,

+ LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId, TraitAliasId,

+ TraitId, TypeAliasId, TypeOrConstParamId, UnionId, UseId,

+pub const BLOCK: Key<ast::BlockExpr, BlockId> = Key::new();

+use hir_expand::{attrs::RawAttrs, name::Name, ExpandTo, HirFileId, InFile};

+use span::{AstIdNode, FileAstId, Span};

+use hir_expand::{mod_path::path, name, name::AsName, span_map::SpanMapRef, HirFileId};

+use span::AstIdMap;

+use span::{AstIdNode, FileAstId, FileId, Span};

+use span::{AstIdMap, AstIdNode};

+ name::Name, proc_macro::ProcMacroKind, HirFileId, InFile, MacroCallId, MacroDefId,

+use span::FileAstId;

+ /// This is the same as [`Self::crate_root`] for crate def maps, but for block def maps, it

+ /// returns the root block module.

+ pub fn root_module_id(&self) -> ModuleId {

+ self.module_id(Self::ROOT)

+ }

+

+use span::{ErasedFileAstId, FileAstId, Span, SyntaxContextId};

+use std::{fmt, hash::BuildHasherDefault, mem};

+ r = r.push_block_scope(def_map);

+ fn push_block_scope(self, def_map: Arc<DefMap>) -> Resolver {

+ debug_assert!(def_map.block_id().is_some());

+ self.push_scope(Scope::BlockScope(ModuleItemMap { def_map, module_id: DefMap::ROOT }))

+ let mut modules: SmallVec<[_; 1]> = smallvec![];

+

+ if !self.is_block_module() {

+ return Resolver { scopes: vec![], module_scope: ModuleItemMap { def_map, module_id } };

+ }

+

+ let block_def_map = mem::replace(&mut def_map, parent.def_map(db));

+ modules.push(block_def_map);

+ if !parent.is_block_module() {

+ module_id = parent.local_id;

+ break;

+ }

+ for def_map in modules.into_iter().rev() {

+ resolver = resolver.push_block_scope(def_map);

+use span::{AstIdMap, SyntaxContextData, SyntaxContextId};

+ hygiene::{span_with_call_site_ctxt, span_with_def_site_ctxt, span_with_mixed_site_ctxt},

+fn ast_id_map(db: &dyn ExpandDatabase, file_id: span::HirFileId) -> triomphe::Arc<AstIdMap> {

+ triomphe::Arc::new(AstIdMap::from_source(&db.parse_or_expand(file_id)))

+}

+

+use span::{

+ AstIdNode, ErasedFileAstId, FileAstId, FileId, FileRange, HirFileId, HirFileIdRepr,

+ MacroFileId, SyntaxContextId,

+};

+use syntax::{AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextSize};

+use crate::{

+ db::{self, ExpandDatabase},

+ map_node_range_up, span_for_offset, MacroFileIdExt,

+};

+/// `AstId` points to an AST node in any file.

+///

+/// It is stable across reparses, and can be used as salsa key/value.

+pub type AstId<N> = crate::InFile<FileAstId<N>>;

+

+impl<N: AstIdNode> AstId<N> {

+ pub fn to_node(&self, db: &dyn ExpandDatabase) -> N {

+ self.to_ptr(db).to_node(&db.parse_or_expand(self.file_id))

+ }

+ pub fn to_in_file_node(&self, db: &dyn ExpandDatabase) -> crate::InFile<N> {

+ crate::InFile::new(self.file_id, self.to_ptr(db).to_node(&db.parse_or_expand(self.file_id)))

+ }

+ pub fn to_ptr(&self, db: &dyn ExpandDatabase) -> AstPtr<N> {

+ db.ast_id_map(self.file_id).get(self.value)

+ }

+}

+

+pub type ErasedAstId = crate::InFile<ErasedFileAstId>;

+

+impl ErasedAstId {

+ pub fn to_ptr(&self, db: &dyn ExpandDatabase) -> SyntaxNodePtr {

+ db.ast_id_map(self.file_id).get_erased(self.value)

+ }

+}

+

+//! Machinery for hygienic macros.

+//! Inspired by Matthew Flatt et al., “Macros That Work Together: Compile-Time Bindings, Partial

+//! Expansion, and Definition Contexts,” *Journal of Functional Programming* 22, no. 2

+//! (March 1, 2012): 181–216, <https://doi.org/10.1017/S0956796812000093>.

+//!

+//! Also see https://rustc-dev-guide.rust-lang.org/macro-expansion.html#hygiene-and-hierarchies

+//!

+//! # The Expansion Order Hierarchy

+//!

+//! `ExpnData` in rustc, rust-analyzer's version is [`MacroCallLoc`]. Traversing the hierarchy

+//! upwards can be achieved by walking up [`MacroCallLoc::kind`]'s contained file id, as

+//! [`MacroFile`]s are interned [`MacroCallLoc`]s.

+//!

+//! # The Macro Definition Hierarchy

+//!

+//! `SyntaxContextData` in rustc and rust-analyzer. Basically the same in both.

+//!

+//! # The Call-site Hierarchy

+//!

+//! `ExpnData::call_site` in rustc, [`MacroCallLoc::call_site`] in rust-analyzer.

+// FIXME: Move this into the span crate? Not quite possible today as that depends on `MacroCallLoc`

+// which contains a bunch of unrelated things

+use span::{MacroCallId, Span, SyntaxContextData, SyntaxContextId};

+pub use span::Transparency;

+ return apply_mark_internal(db, ctxt, call_id, transparency);

+ return apply_mark_internal(db, ctxt, call_id, transparency);

+ apply_mark_internal(db, call_site_ctxt, call_id, transparency)

+ call_id: MacroCallId,

+ use base_db::salsa;

+

+ let call_id = Some(call_id);

+

+

+ fn marks(self, db: &dyn ExpandDatabase) -> Vec<(MacroCallId, Transparency)>;

+ fn marks(self, db: &dyn ExpandDatabase) -> Vec<(MacroCallId, Transparency)> {

+) -> impl Iterator<Item = (MacroCallId, Transparency)> + '_ {

+ iter::successors(Some(ctxt), move |&mark| Some(mark.parent_ctxt(db)))

+ .take_while(|&it| !it.is_root())

+ .map(|ctx| {

+ let mark = ctx.outer_mark(db);

+ // We stop before taking the root expansion, as such we cannot encounter a `None` outer

+ // expansion, as only the ROOT has it.

+ (mark.0.unwrap(), mark.1)

+ })

+ fancy_debug(self.2, self.1, self.0, f)

+

+ fn fancy_debug(

+ this: &SyntaxContextData,

+ self_id: SyntaxContextId,

+ db: &dyn ExpandDatabase,

+ f: &mut std::fmt::Formatter<'_>,

+ ) -> std::fmt::Result {

+ write!(f, "#{self_id} parent: #{}, outer_mark: (", this.parent)?;

+ match this.outer_expn {

+ Some(id) => {

+ write!(f, "{:?}::{{{{expn{:?}}}}}", db.lookup_intern_macro_call(id).krate, id)?

+ }

+ None => write!(f, "root")?,

+ }

+ write!(f, ", {:?})", this.outer_transparency)

+ }

+

+use span::{ErasedFileAstId, FileRange, HirFileIdRepr, Span, SyntaxContextData, SyntaxContextId};

+pub use crate::files::{AstId, ErasedAstId, InFile, InMacroFile, InRealFile};

+ result_mark.map(|call| db.lookup_intern_macro_call(call).def.krate)

+ /// Shortcut to create a name from a string literal.

+use crate::Interner;

+ let checker = filter_map_next_checker.get_or_insert_with(|| {

+ FilterMapNextChecker::new(&self.owner.resolver(db.upcast()), db)

+ });

+

+ if checker.check(call_id, receiver, &callee).is_some() {

+

+ let receiver_ty = self.infer[*receiver].clone();

+ checker.prev_receiver_ty = Some(receiver_ty);

+ prev_receiver_ty: Option<chalk_ir::Ty<Interner>>,

+ Self {

+ filter_map_function_id,

+ next_function_id,

+ prev_filter_map_expr_id: None,

+ prev_receiver_ty: None,

+ }

+ let is_dyn_trait = self

+ .prev_receiver_ty

+ .as_ref()

+ .map_or(false, |it| it.strip_references().dyn_trait().is_some());

+ if *receiver_expr_id == prev_filter_map_expr_id && !is_dyn_trait {

+ BoundVar, DebruijnIndex, FnSubst, Mutability, TyKind,

+ from_chalk_trait_id, from_placeholder_idx, make_binders,

+ mir::{BorrowKind, MirSpan, MutBorrowKind, ProjectionElem},

+ utils::{self, elaborate_clause_supertraits, generics, Generics},

+ Adjust, Adjustment, AliasEq, AliasTy, Binders, BindingMode, ChalkTraitId, ClosureId, DynTy,

+ DynTyExt, FnAbi, FnPointer, FnSig, Interner, OpaqueTy, ProjectionTyExt, Substitution, Ty,

+ TyExt, WhereClause,

+ if let TyKind::Closure(closure_id, _) = closure_ty.kind(Interner) {

+ if let Some(closure_kind) = self.deduce_closure_kind_from_expectations(&expected_ty) {

+ self.result

+ .closure_info

+ .entry(*closure_id)

+ .or_insert_with(|| (Vec::new(), closure_kind));

+ }

+ }

+

+ // Closure kind deductions are mostly from `rustc_hir_typeck/src/closure.rs`.

+ // Might need to port closure sig deductions too.

+ fn deduce_closure_kind_from_expectations(&mut self, expected_ty: &Ty) -> Option<FnTrait> {

+ match expected_ty.kind(Interner) {

+ TyKind::Alias(AliasTy::Opaque(OpaqueTy { .. })) | TyKind::OpaqueType(..) => {

+ let clauses = expected_ty

+ .impl_trait_bounds(self.db)

+ .into_iter()

+ .flatten()

+ .map(|b| b.into_value_and_skipped_binders().0);

+ self.deduce_closure_kind_from_predicate_clauses(clauses)

+ }

+ TyKind::Dyn(dyn_ty) => dyn_ty.principal().and_then(|trait_ref| {

+ self.fn_trait_kind_from_trait_id(from_chalk_trait_id(trait_ref.trait_id))

+ }),

+ TyKind::InferenceVar(ty, chalk_ir::TyVariableKind::General) => {

+ let clauses = self.clauses_for_self_ty(*ty);

+ self.deduce_closure_kind_from_predicate_clauses(clauses.into_iter())

+ }

+ TyKind::Function(_) => Some(FnTrait::Fn),

+ _ => None,

+ }

+ }

+

+ fn deduce_closure_kind_from_predicate_clauses(

+ &self,

+ clauses: impl DoubleEndedIterator<Item = WhereClause>,

+ ) -> Option<FnTrait> {

+ let mut expected_kind = None;

+

+ for clause in elaborate_clause_supertraits(self.db, clauses.rev()) {

+ let trait_id = match clause {

+ WhereClause::AliasEq(AliasEq {

+ alias: AliasTy::Projection(projection), ..

+ }) => Some(projection.trait_(self.db)),

+ WhereClause::Implemented(trait_ref) => {

+ Some(from_chalk_trait_id(trait_ref.trait_id))

+ }

+ _ => None,

+ };

+ if let Some(closure_kind) =

+ trait_id.and_then(|trait_id| self.fn_trait_kind_from_trait_id(trait_id))

+ {

+ // `FnX`'s variants order is opposite from rustc, so use `cmp::max` instead of `cmp::min`

+ expected_kind = Some(

+ expected_kind

+ .map_or_else(|| closure_kind, |current| cmp::max(current, closure_kind)),

+ );

+ }

+ }

+

+ expected_kind

+ }

+

+

+ fn fn_trait_kind_from_trait_id(&self, trait_id: hir_def::TraitId) -> Option<FnTrait> {

+ FnTrait::from_lang_item(self.db.lang_attr(trait_id.into())?)

+ }

+ if let CaptureKind::ByRef(BorrowKind::Mut {

+ kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow,

+ }) = current_capture

+ {

+ current_capture =

+ CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture });

+ CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::Default }),

+ Mutability::Mut => CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::Default }),

+ BorrowKind::Mut { kind: MutBorrowKind::Default },

+ for_mut = BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture };

+ BorrowKind::Mut { kind: MutBorrowKind::Default }

+ CaptureKind::ByRef(BorrowKind::Mut { .. }) => FnTrait::FnMut,

+ if matches!(

+ item.kind,

+ CaptureKind::ByRef(BorrowKind::Mut {

+ kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow

+ })

+ ) && !item.place.projections.contains(&ProjectionElem::Deref)

+ // `closure_kind` should be done before adjust_for_move_closure

+ // If there exists pre-deduced kind of a closure, use it instead of one determined by capture, as rustc does.

+ // rustc also does diagnostics here if the latter is not a subtype of the former.

+ let closure_kind = self

+ .result

+ .closure_info

+ .get(&closure)

+ .map_or_else(|| self.closure_kind(), |info| info.1);

+use smallvec::SmallVec;

+ DebruijnIndex, DomainGoal, GenericArg, GenericArgData, Goal, GoalData, Guidance, InEnvironment,

+ InferenceVar, Interner, Lifetime, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Solution,

+ Substitution, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause,

+

+ pub(super) fn clauses_for_self_ty(

+ &mut self,

+ self_ty: InferenceVar,

+ ) -> SmallVec<[WhereClause; 4]> {

+ self.table.resolve_obligations_as_possible();

+

+ let root = self.table.var_unification_table.inference_var_root(self_ty);

+ let pending_obligations = mem::take(&mut self.table.pending_obligations);

+ let obligations = pending_obligations

+ .iter()

+ .filter_map(|obligation| match obligation.value.value.goal.data(Interner) {

+ GoalData::DomainGoal(DomainGoal::Holds(

+ clause @ WhereClause::AliasEq(AliasEq {

+ alias: AliasTy::Projection(projection),

+ ..

+ }),

+ )) => {

+ let projection_self = projection.self_type_parameter(self.db);

+ let uncanonical = chalk_ir::Substitute::apply(

+ &obligation.free_vars,

+ projection_self,

+ Interner,

+ );

+ if matches!(

+ self.resolve_ty_shallow(&uncanonical).kind(Interner),

+ TyKind::InferenceVar(iv, TyVariableKind::General) if *iv == root,

+ ) {

+ Some(chalk_ir::Substitute::apply(

+ &obligation.free_vars,

+ clause.clone(),

+ Interner,

+ ))

+ } else {

+ None

+ }

+ }

+ GoalData::DomainGoal(DomainGoal::Holds(

+ clause @ WhereClause::Implemented(trait_ref),

+ )) => {

+ let trait_ref_self = trait_ref.self_type_parameter(Interner);

+ let uncanonical = chalk_ir::Substitute::apply(

+ &obligation.free_vars,

+ trait_ref_self,

+ Interner,

+ );

+ if matches!(

+ self.resolve_ty_shallow(&uncanonical).kind(Interner),

+ TyKind::InferenceVar(iv, TyVariableKind::General) if *iv == root,

+ ) {

+ Some(chalk_ir::Substitute::apply(

+ &obligation.free_vars,

+ clause.clone(),

+ Interner,

+ ))

+ } else {

+ None

+ }

+ }

+ _ => None,

+ })

+ .collect();

+ self.table.pending_obligations = pending_obligations;

+

+ obligations

+ }

+ #[tracing::instrument(skip_all)]

+use std::borrow::Cow;

+ fn delayed_bug(&self, txt: impl Into<Cow<'static, str>>) {

+ never!("{}", txt.into());

+ /// Queries whether `self_ty` has potentially applicable implementations of `trait_`.

+ pub fn has_impls_for_trait_and_self_ty(&self, trait_: TraitId, self_ty: TyFingerprint) -> bool {

+ self.for_trait_and_self_ty(trait_, self_ty).next().is_some()

+ }

+

+ if data.skip_array_during_method_dispatch

+ && matches!(self_ty.kind(Interner), chalk_ir::TyKind::Array(..))

+ {

+ let visible =

+ match is_valid_trait_method_candidate(table, t, name, receiver_ty, item, self_ty) {

+ IsValidCandidate::Yes => true,

+ IsValidCandidate::NotVisible => false,

+ IsValidCandidate::No => continue,

+ };

+ let visible = match is_valid_trait_method_candidate(

+ table,

+ t,

+ name,

+ receiver_ty,

+ item,

+ self_ty,

+ ) {

+ IsValidCandidate::Yes => true,

+ IsValidCandidate::NotVisible => false,

+ IsValidCandidate::No => continue,

+ };

+ for &impl_id in impls.for_self_ty(self_ty) {

+ for &item in &table.db.impl_data(impl_id).items {

+ let visible = match is_valid_impl_method_candidate(

+ receiver_ty,

+ name,

+ impl_id,

+ item,

+enum IsValidCandidate {

+ Yes,

+ No,

+ NotVisible,

+}

+

+fn is_valid_impl_method_candidate(

+ receiver_ty: Option<&Ty>,

+ name: Option<&Name>,

+ impl_id: ImplId,

+ item: AssocItemId,

+ AssocItemId::FunctionId(f) => is_valid_impl_fn_candidate(

+ table,

+ impl_id,

+ f,

+ name,

+ receiver_ty,

+ self_ty,

+ visible_from_module,

+ ),

+ let db = table.db;

+ let self_ty_matches = table.run_in_snapshot(|table| {

+ let expected_self_ty =

+ TyBuilder::impl_self_ty(db, impl_id).fill_with_inference_vars(table).build();

+ table.unify(&expected_self_ty, self_ty)

+ });

+ if !self_ty_matches {

+ cov_mark::hit!(const_candidate_self_type_mismatch);

+ return IsValidCandidate::No;

+/// Checks whether a given `AssocItemId` is applicable for `receiver_ty`.

+#[tracing::instrument(skip_all, fields(name))]

+fn is_valid_trait_method_candidate(

+ table: &mut InferenceTable<'_>,

+ trait_id: TraitId,

+ name: Option<&Name>,

+ receiver_ty: Option<&Ty>,

+ item: AssocItemId,

+ self_ty: &Ty,

+) -> IsValidCandidate {

+ let db = table.db;

+ match item {

+ AssocItemId::FunctionId(fn_id) => {

+ let data = db.function_data(fn_id);

+

+ check_that!(name.map_or(true, |n| n == &data.name));

+

+ table.run_in_snapshot(|table| {

+ let impl_subst = TyBuilder::subst_for_def(db, trait_id, None)

+ .fill_with_inference_vars(table)

+ .build();

+ let expect_self_ty = impl_subst.at(Interner, 0).assert_ty_ref(Interner).clone();

+

+ check_that!(table.unify(&expect_self_ty, self_ty));

+

+ if let Some(receiver_ty) = receiver_ty {

+ check_that!(data.has_self_param());

+

+ let fn_subst = TyBuilder::subst_for_def(db, fn_id, Some(impl_subst.clone()))

+ .fill_with_inference_vars(table)

+ .build();

+

+ let sig = db.callable_item_signature(fn_id.into());

+ let expected_receiver =

+ sig.map(|s| s.params()[0].clone()).substitute(Interner, &fn_subst);

+

+ check_that!(table.unify(receiver_ty, &expected_receiver));

+ }

+

+ IsValidCandidate::Yes

+ })

+ }

+ AssocItemId::ConstId(c) => {

+ check_that!(receiver_ty.is_none());

+ check_that!(name.map_or(true, |n| db.const_data(c).name.as_ref() == Some(n)));

+

+ IsValidCandidate::Yes

+ }

+ _ => IsValidCandidate::No,

+ }

+fn is_valid_impl_fn_candidate(

+ impl_id: ImplId,

+ let _p = tracing::span!(tracing::Level::INFO, "subst_for_def").entered();

+ let impl_subst =

+ TyBuilder::subst_for_def(db, impl_id, None).fill_with_inference_vars(table).build();

+ let expect_self_ty = db.impl_self_ty(impl_id).substitute(Interner, &impl_subst);

+ let _p = tracing::span!(tracing::Level::INFO, "check_receiver_ty").entered();

+ // We need to consider the bounds on the impl to distinguish functions of the same name

+ // for a type.

+ let predicates = db.generic_predicates(impl_id.into());

+ let goals = predicates.iter().map(|p| {

+ let (p, b) = p

+ .clone()

+ .substitute(Interner, &impl_subst)

+ // Skipping the inner binders is ok, as we don't handle quantified where

+ // clauses yet.

+ .into_value_and_skipped_binders();

+ stdx::always!(b.len(Interner) == 0);

+

+ p.cast::<Goal>(Interner)

+ });

+

+ for goal in goals.clone() {

+ let in_env = InEnvironment::new(&table.trait_env.env, goal);

+ let canonicalized = table.canonicalize(in_env);

+ let solution = table.db.trait_solve(

+ table.trait_env.krate,

+ table.trait_env.block,

+ canonicalized.value.clone(),

+ );

+

+ match solution {

+ Some(Solution::Unique(canonical_subst)) => {

+ canonicalized.apply_solution(

+ table,

+ Canonical {

+ binders: canonical_subst.binders,

+ value: canonical_subst.value.subst,

+ },

+ );

+ Some(Solution::Ambig(Guidance::Definite(substs))) => {

+ canonicalized.apply_solution(table, substs);

+ Some(_) => (),

+ None => return IsValidCandidate::No,

+ }

+ for goal in goals {

+ if table.try_obligation(goal).is_none() {

+ return IsValidCandidate::No;

+ }

+

+ IsValidCandidate::Yes

+ Mut { kind: MutBorrowKind },

+}

+

+#[derive(Debug, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]

+pub enum MutBorrowKind {

+ Default,

+ /// This borrow arose from method-call auto-ref

+ /// (i.e., adjustment::Adjust::Borrow).

+ TwoPhasedBorrow,

+ /// Data must be immutable but not aliasable. This kind of borrow cannot currently

+ /// be expressed by the user and is used only in implicit closure bindings.

+ ClosureCapture,

+ hir_def::type_ref::Mutability::Mut => BorrowKind::Mut { kind: MutBorrowKind::Default },

+ Mutability::Mut => BorrowKind::Mut { kind: MutBorrowKind::Default },

+ BasicBlockId, BorrowKind, LocalId, MirBody, MirLowerError, MirSpan, MutBorrowKind, Place,

+ ProjectionElem, Rvalue, StatementKind, TerminatorKind,

+ if let Rvalue::Ref(

+ BorrowKind::Mut {

+ kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow,

+ },

+ p,

+ ) = value

+ {

+use crate::mir::MutBorrowKind;

+

+ BorrowKind::Mut { kind: MutBorrowKind::Default },

+ mir::{

+ lower::{

+ BasicBlockId, BinOp, BindingId, BorrowKind, Either, Expr, FieldId, Idx, Interner,

+ MemoryMap, MirLowerCtx, MirLowerError, MirSpan, Mutability, Operand, Pat, PatId, Place,

+ PlaceElem, ProjectionElem, RecordFieldPat, ResolveValueResult, Result, Rvalue,

+ Substitution, SwitchTargets, TerminatorKind, TupleFieldId, TupleId, TyBuilder, TyKind,

+ ValueNs, VariantData, VariantId,

+ },

+ MutBorrowKind,

+ Rvalue::Ref(BorrowKind::Mut { kind: MutBorrowKind::Default }, cond_place)

+ AggregateKind, BasicBlockId, BorrowKind, LocalId, MirBody, MutBorrowKind, Operand, Place,

+ Rvalue, UnOp,

+ BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture } => w!(self, "&uniq "),

+ BorrowKind::Mut {

+ kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow,

+ } => w!(self, "&mut "),

+ 78..81 'foo': fn foo<&(i32, &str), i32, impl FnOnce(&(i32, &str)) -> i32>(&(i32, &str), impl FnOnce(&(i32, &str)) -> i32) -> i32

+ 93..104 '|&(x, y)| x': impl FnOnce(&(i32, &str)) -> i32

+ 142..145 'foo': fn foo<&(i32, &str), &i32, impl FnOnce(&(i32, &str)) -> &i32>(&(i32, &str), impl FnOnce(&(i32, &str)) -> &i32) -> &i32

+ 157..167 '|(x, y)| x': impl FnOnce(&(i32, &str)) -> &i32

+ 136..143 '|_x| {}': impl FnOnce(&i32)

+ 167..171 'test': fn test<(), (), impl FnMut() -> impl Future<Output = Result<(), ()>>, impl Future<Output = Result<(), ()>>>(impl FnMut() -> impl Future<Output = Result<(), ()>>)

+ 172..227 '|| asy... }': impl FnMut() -> impl Future<Output = Result<(), ()>>

+fn closure_kind_with_predicates() {

+ check_types(

+ r#"

+//- minicore: fn

+#![feature(unboxed_closures)]

+

+struct X<T: FnOnce()>(T);

+

+fn f1() -> impl FnOnce() {

+ || {}

+ // ^^^^^ impl FnOnce()

+}

+

+fn f2(c: impl FnOnce<(), Output = i32>) {}

+

+fn test {

+ let x1 = X(|| {});

+ let c1 = x1.0;

+ // ^^ impl FnOnce()

+

+ let c2 = || {};

+ // ^^ impl Fn()

+ let x2 = X(c2);

+ let c3 = x2.0

+ // ^^ impl Fn()

+

+ let c4 = f1();

+ // ^^ impl FnOnce() + ?Sized

+

+ f2(|| { 0 });

+ // ^^^^^^^^ impl FnOnce() -> i32

+}

+ "#,

+ )

+}

+

+#[test]

+ 134..165 '{ ...(C)) }': (impl FnOnce(&str, T), Bar<u8>)

+ 140..163 '(|inpu...ar(C))': (impl FnOnce(&str, T), Bar<u8>)

+ 141..154 '|input, t| {}': impl FnOnce(&str, T)

+ 180..189 '|v| v + 1': impl FnOnce(u32) -> u32

+ 202..211 '|_v| 1u64': impl FnOnce(u32) -> u64

+ 245..251 '|_v| 1': impl FnOnce(u32) -> i64

+ 345..349 'foo1': fn foo1<S, u64, impl FnOnce(S) -> u64>(S, impl FnOnce(S) -> u64) -> u64

+ 353..367 '|s| s.method()': impl FnOnce(S) -> u64

+ 383..387 'foo2': fn foo2<S, u64, impl FnOnce(S) -> u64>(impl FnOnce(S) -> u64, S) -> u64

+ 388..402 '|s| s.method()': impl FnOnce(S) -> u64

+ 431..445 '|s| s.method()': impl FnOnce(S) -> u64

+ 468..482 '|s| s.method()': impl FnOnce(S) -> u64

+ 138..148 'f::<(), _>': fn f<(), impl FnOnce(&())>(impl FnOnce(&()))

+ 149..159 '|z| { z; }': impl FnOnce(&())

+ 983..1075 'Vec::<...one })': FilterMap<IntoIter<i32>, impl FnMut(i32) -> Option<u32>>

+ 1029..1074 '|x| if...None }': impl FnMut(i32) -> Option<u32>

+ 1090..1100 '|y| { y; }': impl FnMut(u32)

+ 294..308 '&mut (|ps| {})': &mut impl FnOnce(&Option<i32>)

+ 300..307 '|ps| {}': impl FnOnce(&Option<i32>)

+ let _p = tracing::span!(tracing::Level::INFO, "solve", ?krate, ?block).entered();

+ pub const fn from_lang_item(lang_item: LangItem) -> Option<Self> {

+ match lang_item {

+ LangItem::FnOnce => Some(FnTrait::FnOnce),

+ LangItem::FnMut => Some(FnTrait::FnMut),

+ LangItem::Fn => Some(FnTrait::Fn),

+ _ => None,

+ }

+ }

+

+pub(super) fn elaborate_clause_supertraits(

+ db: &dyn HirDatabase,

+ clauses: impl Iterator<Item = WhereClause>,

+) -> ClauseElaborator<'_> {

+ let mut elaborator = ClauseElaborator { db, stack: Vec::new(), seen: FxHashSet::default() };

+ elaborator.extend_deduped(clauses);

+

+ elaborator

+}

+

+pub(super) struct ClauseElaborator<'a> {

+ db: &'a dyn HirDatabase,

+ stack: Vec<WhereClause>,

+ seen: FxHashSet<WhereClause>,

+}

+

+impl<'a> ClauseElaborator<'a> {

+ fn extend_deduped(&mut self, clauses: impl IntoIterator<Item = WhereClause>) {

+ self.stack.extend(clauses.into_iter().filter(|c| self.seen.insert(c.clone())))

+ }

+

+ fn elaborate_supertrait(&mut self, clause: &WhereClause) {

+ if let WhereClause::Implemented(trait_ref) = clause {

+ direct_super_trait_refs(self.db, trait_ref, |t| {

+ let clause = WhereClause::Implemented(t);

+ if self.seen.insert(clause.clone()) {

+ self.stack.push(clause);

+ }

+ });

+ }

+ }

+}

+

+impl Iterator for ClauseElaborator<'_> {

+ type Item = WhereClause;

+

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

+ if let Some(next) = self.stack.pop() {

+ self.elaborate_supertrait(&next);

+ Some(next)

+ } else {

+ None

+ }

+ }

+}

+

+ let mut modpath = doc_modpath_from_str(link)?;

+fn doc_modpath_from_str(link: &str) -> Option<ModPath> {

+ Err(_) => {

+ Name::new_text_dont_use(segment.split_once('<').map_or(segment, |it| it.0).into())

+ }

+ let expr_syntax = |expr| {

+ source_map.expr_syntax(expr).inspect_err(|_| tracing::error!("synthetic syntax")).ok()

+ };

+ let pat_syntax = |pat| {

+ source_map.pat_syntax(pat).inspect_err(|_| tracing::error!("synthetic syntax")).ok()

+ };

+ MismatchedArgCount { call_expr: expr_syntax(call_expr)?, expected, found }.into()

+ let expr = expr_syntax(expr)?;

+ ExprOrPatId::ExprId(expr) => expr_syntax(expr)?.map(AstPtr::wrap_left),

+ ExprOrPatId::PatId(pat) => pat_syntax(pat)?.map(AstPtr::wrap_right),

+ let call_expr = expr_syntax(*call_expr)?;

+ let expr = expr_syntax(*expr)?;

+ let expr = expr_syntax(*expr)?;

+ ExprOrPatId::ExprId(expr) => expr_syntax(expr)?.map(AstPtr::wrap_left),

+ ExprOrPatId::PatId(pat) => pat_syntax(pat)?.map(AstPtr::wrap_right),

+ let expr = expr_syntax(expr)?;

+ let expr = expr_syntax(expr)?;

+ let expr = expr_syntax(*expr)?;

+ ExprOrPatId::ExprId(expr) => expr_syntax(expr)?.map(AstPtr::wrap_left),

+ let InFile { file_id, value } = pat_syntax(pat)?;

+ mir::{interpret_mir, MutBorrowKind},

+ DescendPreference, PathResolution, Semantics, SemanticsImpl, SemanticsScope, TypeInfo,

+ VisibleTraits,

+#[derive(Clone, PartialEq, Eq, Hash, Debug)]

+ hir_ty::CaptureKind::ByRef(hir_ty::mir::BorrowKind::Mut {

+ kind: MutBorrowKind::ClosureCapture,

+ }) => CaptureKind::UniqueSharedRef,

+ hir_ty::CaptureKind::ByRef(hir_ty::mir::BorrowKind::Mut {

+ kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow,

+ }) => CaptureKind::MutableRef,

+ pub fn new_tuple(krate: CrateId, tys: &[Type]) -> Type {

+ let tys = tys.iter().map(|it| it.ty.clone());

+ Type { env: TraitEnvironment::empty(krate), ty: TyBuilder::tuple_with(tys) }

+ }

+

+ pub fn fingerprint_for_trait_impl(&self) -> Option<TyFingerprint> {

+ TyFingerprint::for_trait_impl(&self.ty)

+ }

+

+ .map(|(_, substs)| substs)

+ .or_else(|| self.ty.strip_references().as_tuple())

+ .flat_map(|substs| substs.iter(Interner))

+ let call_node = file_id.macro_file()?.call_node(db);

+ // cache the node

+ self.parse_or_expand(call_node.file_id);

+ Some(call_node)

+ pub fn resolve_expr_as_callable(&self, call: &ast::Expr) -> Option<Callable> {

+ self.analyze(call.syntax())?.resolve_expr_as_callable(self.db, call)

+ }

+

+use either::Either;

+ AdtId, BlockId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId, ExternCrateId,

+ FieldId, FunctionId, GenericDefId, GenericParamId, ImplId, LifetimeParamId, MacroId, ModuleId,

+ StaticId, StructId, TraitAliasId, TraitId, TypeAliasId, TypeParamId, UnionId, UseId, VariantId,

+ pub(super) fn module_to_def(&mut self, src: InFile<ast::Module>) -> Option<ModuleId> {

+ .find_map(|it| it.map(Either::<ast::Module, ast::BlockExpr>::cast).transpose())

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

+ Some(Either::Right(parent_block)) => self

+ .block_to_def(parent_block)

+ .map(|block| self.db.block_def_map(block).root_module_id()),

+ Some(Either::Left(parent_declaration)) => self.module_to_def(parent_declaration),

+ pub(super) fn block_to_def(&mut self, src: InFile<ast::BlockExpr>) -> Option<BlockId> {

+ self.to_def(src, keys::BLOCK)

+ }

+ pub(crate) fn resolve_expr_as_callable(

+ &self,

+ db: &dyn HirDatabase,

+ call: &ast::Expr,

+ ) -> Option<Callable> {

+ self.type_of_expr(db, &call.clone())?.0.as_callable(db)

+ }

+

+ let (op_trait, op_fn) = match prefix_expr.op_kind()? {

+ ast::UnaryOp::Deref => {

+ // This can be either `Deref::deref` or `DerefMut::deref_mut`.

+ // Since deref kind is inferenced and stored in `InferenceResult.method_resolution`,

+ // use that result to find out which one it is.

+ let (deref_trait, deref) =

+ self.lang_trait_fn(db, LangItem::Deref, &name![deref])?;

+ self.infer

+ .as_ref()

+ .and_then(|infer| {

+ let expr = self.expr_id(db, &prefix_expr.clone().into())?;

+ let (func, _) = infer.method_resolution(expr)?;

+ let (deref_mut_trait, deref_mut) =

+ self.lang_trait_fn(db, LangItem::DerefMut, &name![deref_mut])?;

+ if func == deref_mut {

+ Some((deref_mut_trait, deref_mut))

+ } else {

+ None

+ }

+ })

+ .unwrap_or((deref_trait, deref))

+ }

+ ast::UnaryOp::Not => self.lang_trait_fn(db, LangItem::Not, &name![not])?,

+ ast::UnaryOp::Neg => self.lang_trait_fn(db, LangItem::Neg, &name![neg])?,

+

+ let (index_trait, index_fn) = self.lang_trait_fn(db, LangItem::Index, &name![index])?;

+ let (op_trait, op_fn) = self

+ .infer

+ .as_ref()

+ .and_then(|infer| {

+ let expr = self.expr_id(db, &index_expr.clone().into())?;

+ let (func, _) = infer.method_resolution(expr)?;

+ let (index_mut_trait, index_mut_fn) =

+ self.lang_trait_fn(db, LangItem::IndexMut, &name![index_mut])?;

+ if func == index_mut_fn {

+ Some((index_mut_trait, index_mut_fn))

+ } else {

+ None

+ }

+ })

+ .unwrap_or((index_trait, index_fn));

+

+ fn is_many(&self) -> bool {

+ matches!(self, AlternativeExprs::Many)

+ }

+ fn new(many_threshold: usize, goal: Type) -> Self {

+ res.types_wishlist.insert(goal);

+ fn find(&mut self, db: &dyn HirDatabase, ty: &Type) -> Option<Vec<Expr>> {

+ let res = self

+ .data

+ .map(|(t, tts)| tts.exprs(t));

+

+ if res.is_none() {

+ self.types_wishlist.insert(ty.clone());

+ }

+

+ res

+ fn find_autoref(&mut self, db: &dyn HirDatabase, ty: &Type) -> Option<Vec<Expr>> {

+ let res = self

+ .data

+ });

+

+ if res.is_none() {

+ self.types_wishlist.insert(ty.clone());

+ }

+

+ res

+ Some(it) => {

+ it.extend_with_threshold(self.many_threshold, exprs);

+ if it.is_many() {

+ self.types_wishlist.remove(&ty);

+ }

+ }

+ fn types_wishlist(&mut self) -> &FxHashSet<Type> {

+ &self.types_wishlist

+ let mut lookup = LookupTable::new(ctx.config.many_alternatives_threshold, ctx.goal.clone());

+ solutions.extend(tactics::make_tuple(ctx, &defs, &mut lookup));

+ /// Tuple construction

+ Tuple { ty: Type, params: Vec<Expr> },

+ Expr::Tuple { params, .. } => {

+ let args = params

+ .iter()

+ .map(|a| {

+ a.gen_source_code(sema_scope, many_formatter, prefer_no_std, prefer_prelude)

+ })

+ .collect::<Result<Vec<String>, DisplaySourceCodeError>>()?

+ .into_iter()

+ .join(", ");

+ let res = format!("({args})");

+ Ok(res)

+ }

+ Expr::Tuple { ty, .. } => ty.clone(),

+ let enum_ty_shallow = Adt::from(parent_enum).ty(db);

+ .types_wishlist()

+ .clone()

+ .filter(|ty| ty.could_unify_with(db, &enum_ty_shallow))

+ .map(|it| it.type_arguments().collect::<Vec<Type>>())

+ .chain((non_default_type_params_len == 0).then_some(Vec::new()));

+ .map(|it| it.default(db).or_else(|| g.next()))

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

+ variant_helper(db, lookup, it.parent_enum(db), *it, &ctx.config);

+ if GenericDef::from(it.parent_enum(db))

+ .type_or_const_params(db)

+ .into_iter()

+ .filter_map(|it| it.as_type_param(db))

+ .all(|it| it.default(db).is_some())

+ {

+ lookup.mark_fulfilled(ScopeDef::ModuleDef(ModuleDef::Variant(*it)));

+ }

+ .flat_map(|it| variant_helper(db, lookup, *enum_, it, &ctx.config))

+ if exprs.is_empty() {

+ return None;

+ }

+

+ if GenericDef::from(*enum_)

+ .type_or_const_params(db)

+ .into_iter()

+ .filter_map(|it| it.as_type_param(db))

+ .all(|it| it.default(db).is_some())

+ {

+ let struct_ty_shallow = Adt::from(*it).ty(db);

+ .types_wishlist()

+ .clone()

+ .filter(|ty| ty.could_unify_with(db, &struct_ty_shallow))

+ .map(|it| it.type_arguments().collect::<Vec<Type>>())

+ .chain((non_default_type_params_len == 0).then_some(Vec::new()));

+ .map(|it| it.default(db).or_else(|| g.next()))

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

+ if non_default_type_params_len == 0 {

+ // Fulfilled only if there are no generic parameters

+ lookup.mark_fulfilled(ScopeDef::ModuleDef(ModuleDef::Adt(

+ Adt::Struct(*it),

+ )));

+ }

+ // Double check that we have fully known type

+ if ty.type_arguments().any(|it| it.contains_unknown()) {

+ return None;

+ }

+

+ let non_default_fn_type_params_len =

+ fn_type_params.iter().filter(|it| it.default(db).is_none()).count();

+ // Ignore functions with generics for now as they kill the performance

+ // Also checking bounds for generics is problematic

+ if non_default_fn_type_params_len > 0 {

+ .permutations(non_default_fn_type_params_len);

+ let generics: Vec<_> = ty

+ .type_arguments()

+ .map(Some)

+ .chain(fn_type_params.iter().map(|it| match it.default(db) {

+ }))

+ .types_wishlist()

+ .clone()

+ // Double check that we have fully known type

+ if ty.type_arguments().any(|it| it.contains_unknown()) {

+ return None;

+ }

+

+ let non_default_fn_type_params_len =

+ fn_type_params.iter().filter(|it| it.default(db).is_none()).count();

+ // Ignore functions with generics for now as they kill the performance

+ // Also checking bounds for generics is problematic

+ if non_default_fn_type_params_len > 0 {

+ .permutations(non_default_fn_type_params_len);

+ let generics: Vec<_> = ty

+ .type_arguments()

+ .map(Some)

+ .chain(fn_type_params.iter().map(|it| match it.default(db) {

+ }))

+

+/// # Make tuple tactic

+///

+/// Attempts to create tuple types if any are listed in types wishlist

+///

+/// Updates lookup by new types reached and returns iterator that yields

+/// elements that unify with `goal`.

+///

+/// # Arguments

+/// * `ctx` - Context for the term search

+/// * `defs` - Set of items in scope at term search target location

+/// * `lookup` - Lookup table for types

+pub(super) fn make_tuple<'a, DB: HirDatabase>(

+ ctx: &'a TermSearchCtx<'a, DB>,

+ _defs: &'a FxHashSet<ScopeDef>,

+ lookup: &'a mut LookupTable,

+) -> impl Iterator<Item = Expr> + 'a {

+ let db = ctx.sema.db;

+ let module = ctx.scope.module();

+

+ lookup

+ .types_wishlist()

+ .clone()

+ .into_iter()

+ .filter(|ty| ty.is_tuple())

+ .filter_map(move |ty| {

+ // Double check to not contain unknown

+ if ty.contains_unknown() {

+ return None;

+ }

+

+ // Ignore types that have something to do with lifetimes

+ if ctx.config.enable_borrowcheck && ty.contains_reference(db) {

+ return None;

+ }

+

+ // Early exit if some param cannot be filled from lookup

+ let param_exprs: Vec<Vec<Expr>> =

+ ty.type_arguments().map(|field| lookup.find(db, &field)).collect::<Option<_>>()?;

+

+ let exprs: Vec<Expr> = param_exprs

+ .into_iter()

+ .multi_cartesian_product()

+ .map(|params| {

+ let tys: Vec<Type> = params.iter().map(|it| it.ty(db)).collect();

+ let tuple_ty = Type::new_tuple(module.krate().into(), &tys);

+

+ let expr = Expr::Tuple { ty: tuple_ty.clone(), params };

+ lookup.insert(tuple_ty, iter::once(expr.clone()));

+ expr

+ })

+ .collect();

+

+ Some(exprs)

+ })

+ .flatten()

+ .filter_map(|expr| expr.ty(db).could_unify_with_deeply(db, &ctx.goal).then_some(expr))

+}

+ ), None),

+use hir::HasVisibility;

+use ide_db::{

+ assists::{AssistId, AssistKind},

+ defs::Definition,

+ helpers::mod_path_to_ast,

+ search::{FileReference, SearchScope},

+ FxHashMap, FxHashSet,

+};

+use itertools::Itertools;

+use syntax::{ast, ted, AstNode, SmolStr, SyntaxNode};

+use text_edit::TextRange;

+

+use crate::{

+ assist_context::{AssistContext, Assists, SourceChangeBuilder},

+ utils::ref_field_expr::determine_ref_and_parens,

+};

+

+// Assist: destructure_struct_binding

+//

+// Destructures a struct binding in place.

+//

+// ```

+// struct Foo {

+// bar: i32,

+// baz: i32,

+// }

+// fn main() {

+// let $0foo = Foo { bar: 1, baz: 2 };

+// let bar2 = foo.bar;

+// let baz2 = &foo.baz;

+// }

+// ```

+// ->

+// ```

+// struct Foo {

+// bar: i32,

+// baz: i32,

+// }

+// fn main() {

+// let Foo { bar, baz } = Foo { bar: 1, baz: 2 };

+// let bar2 = bar;

+// let baz2 = &baz;

+// }

+// ```

+pub(crate) fn destructure_struct_binding(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {

+ let ident_pat = ctx.find_node_at_offset::<ast::IdentPat>()?;

+ let data = collect_data(ident_pat, ctx)?;

+

+ acc.add(

+ AssistId("destructure_struct_binding", AssistKind::RefactorRewrite),

+ "Destructure struct binding",

+ data.ident_pat.syntax().text_range(),

+ |edit| destructure_struct_binding_impl(ctx, edit, &data),

+ );

+

+ Some(())

+}

+

+fn destructure_struct_binding_impl(

+ ctx: &AssistContext<'_>,

+ builder: &mut SourceChangeBuilder,

+ data: &StructEditData,

+) {

+ let field_names = generate_field_names(ctx, data);

+ let assignment_edit = build_assignment_edit(ctx, builder, data, &field_names);

+ let usage_edits = build_usage_edits(ctx, builder, data, &field_names.into_iter().collect());

+

+ assignment_edit.apply();

+ for edit in usage_edits {

+ edit.apply(builder);

+ }

+}

+

+struct StructEditData {

+ ident_pat: ast::IdentPat,

+ kind: hir::StructKind,

+ struct_def_path: hir::ModPath,

+ visible_fields: Vec<hir::Field>,

+ usages: Vec<FileReference>,

+ names_in_scope: FxHashSet<SmolStr>,

+ has_private_members: bool,

+ is_nested: bool,

+ is_ref: bool,

+}

+

+fn collect_data(ident_pat: ast::IdentPat, ctx: &AssistContext<'_>) -> Option<StructEditData> {

+ let ty = ctx.sema.type_of_binding_in_pat(&ident_pat)?;

+ let hir::Adt::Struct(struct_type) = ty.strip_references().as_adt()? else { return None };

+

+ let module = ctx.sema.scope(ident_pat.syntax())?.module();

+ let struct_def = hir::ModuleDef::from(struct_type);

+ let kind = struct_type.kind(ctx.db());

+ let struct_def_path = module.find_use_path(

+ ctx.db(),

+ struct_def,

+ ctx.config.prefer_no_std,

+ ctx.config.prefer_prelude,

+ )?;

+

+ let is_non_exhaustive = struct_def.attrs(ctx.db())?.by_key("non_exhaustive").exists();

+ let is_foreign_crate =

+ struct_def.module(ctx.db()).map_or(false, |m| m.krate() != module.krate());

+

+ let fields = struct_type.fields(ctx.db());

+ let n_fields = fields.len();

+

+ let visible_fields =

+ fields.into_iter().filter(|field| field.is_visible_from(ctx.db(), module)).collect_vec();

+

+ let has_private_members =

+ (is_non_exhaustive && is_foreign_crate) || visible_fields.len() < n_fields;

+

+ // If private members are present, we can only destructure records

+ if !matches!(kind, hir::StructKind::Record) && has_private_members {

+ return None;

+ }

+

+ let is_ref = ty.is_reference();

+ let is_nested = ident_pat.syntax().parent().and_then(ast::RecordPatField::cast).is_some();

+

+ let usages = ctx

+ .sema

+ .to_def(&ident_pat)

+ .and_then(|def| {

+ Definition::Local(def)

+ .usages(&ctx.sema)

+ .in_scope(&SearchScope::single_file(ctx.file_id()))

+ .all()

+ .iter()

+ .next()

+ .map(|(_, refs)| refs.to_vec())

+ })

+ .unwrap_or_default();

+

+ let names_in_scope = get_names_in_scope(ctx, &ident_pat, &usages).unwrap_or_default();

+

+ Some(StructEditData {

+ ident_pat,

+ kind,

+ struct_def_path,

+ usages,

+ has_private_members,

+ visible_fields,

+ names_in_scope,

+ is_nested,

+ is_ref,

+ })

+}

+

+fn get_names_in_scope(

+ ctx: &AssistContext<'_>,

+ ident_pat: &ast::IdentPat,

+ usages: &[FileReference],

+) -> Option<FxHashSet<SmolStr>> {

+ fn last_usage(usages: &[FileReference]) -> Option<SyntaxNode> {

+ usages.last()?.name.syntax().into_node()

+ }

+

+ // If available, find names visible to the last usage of the binding

+ // else, find names visible to the binding itself

+ let last_usage = last_usage(usages);

+ let node = last_usage.as_ref().unwrap_or(ident_pat.syntax());

+ let scope = ctx.sema.scope(node)?;

+

+ let mut names = FxHashSet::default();

+ scope.process_all_names(&mut |name, scope| {

+ if let (Some(name), hir::ScopeDef::Local(_)) = (name.as_text(), scope) {

+ names.insert(name);

+ }

+ });

+ Some(names)

+}

+

+fn build_assignment_edit(

+ _ctx: &AssistContext<'_>,

+ builder: &mut SourceChangeBuilder,

+ data: &StructEditData,

+ field_names: &[(SmolStr, SmolStr)],

+) -> AssignmentEdit {

+ let ident_pat = builder.make_mut(data.ident_pat.clone());

+

+ let struct_path = mod_path_to_ast(&data.struct_def_path);

+ let is_ref = ident_pat.ref_token().is_some();

+ let is_mut = ident_pat.mut_token().is_some();

+

+ let new_pat = match data.kind {

+ hir::StructKind::Tuple => {

+ let ident_pats = field_names.iter().map(|(_, new_name)| {

+ let name = ast::make::name(new_name);

+ ast::Pat::from(ast::make::ident_pat(is_ref, is_mut, name))

+ });

+ ast::Pat::TupleStructPat(ast::make::tuple_struct_pat(struct_path, ident_pats))

+ }

+ hir::StructKind::Record => {

+ let fields = field_names.iter().map(|(old_name, new_name)| {

+ // Use shorthand syntax if possible

+ if old_name == new_name && !is_mut {

+ ast::make::record_pat_field_shorthand(ast::make::name_ref(old_name))

+ } else {

+ ast::make::record_pat_field(

+ ast::make::name_ref(old_name),

+ ast::Pat::IdentPat(ast::make::ident_pat(

+ is_ref,

+ is_mut,

+ ast::make::name(new_name),

+ )),

+ )

+ }

+ });

+

+ let field_list = ast::make::record_pat_field_list(

+ fields,

+ data.has_private_members.then_some(ast::make::rest_pat()),

+ );

+ ast::Pat::RecordPat(ast::make::record_pat_with_fields(struct_path, field_list))

+ }

+ hir::StructKind::Unit => ast::make::path_pat(struct_path),

+ };

+

+ // If the binding is nested inside a record, we need to wrap the new

+ // destructured pattern in a non-shorthand record field

+ let new_pat = if data.is_nested {

+ let record_pat_field =

+ ast::make::record_pat_field(ast::make::name_ref(&ident_pat.to_string()), new_pat)

+ .clone_for_update();

+ NewPat::RecordPatField(record_pat_field)

+ } else {

+ NewPat::Pat(new_pat.clone_for_update())

+ };

+

+ AssignmentEdit { old_pat: ident_pat, new_pat }

+}

+

+fn generate_field_names(ctx: &AssistContext<'_>, data: &StructEditData) -> Vec<(SmolStr, SmolStr)> {

+ match data.kind {

+ hir::StructKind::Tuple => data

+ .visible_fields

+ .iter()

+ .enumerate()

+ .map(|(index, _)| {

+ let new_name = new_field_name((format!("_{}", index)).into(), &data.names_in_scope);

+ (index.to_string().into(), new_name)

+ })

+ .collect(),

+ hir::StructKind::Record => data

+ .visible_fields

+ .iter()

+ .map(|field| {

+ let field_name = field.name(ctx.db()).to_smol_str();

+ let new_name = new_field_name(field_name.clone(), &data.names_in_scope);

+ (field_name, new_name)

+ })

+ .collect(),

+ hir::StructKind::Unit => Vec::new(),

+ }

+}

+

+fn new_field_name(base_name: SmolStr, names_in_scope: &FxHashSet<SmolStr>) -> SmolStr {

+ let mut name = base_name.clone();

+ let mut i = 1;

+ while names_in_scope.contains(&name) {

+ name = format!("{base_name}_{i}").into();

+ i += 1;

+ }

+ name

+}

+

+struct AssignmentEdit {

+ old_pat: ast::IdentPat,

+ new_pat: NewPat,

+}

+

+enum NewPat {

+ Pat(ast::Pat),

+ RecordPatField(ast::RecordPatField),

+}

+

+impl AssignmentEdit {

+ fn apply(self) {

+ match self.new_pat {

+ NewPat::Pat(pat) => ted::replace(self.old_pat.syntax(), pat.syntax()),

+ NewPat::RecordPatField(record_pat_field) => {

+ ted::replace(self.old_pat.syntax(), record_pat_field.syntax())

+ }

+ }

+ }

+}

+

+fn build_usage_edits(

+ ctx: &AssistContext<'_>,

+ builder: &mut SourceChangeBuilder,

+ data: &StructEditData,

+ field_names: &FxHashMap<SmolStr, SmolStr>,

+) -> Vec<StructUsageEdit> {

+ data.usages

+ .iter()

+ .filter_map(|r| build_usage_edit(ctx, builder, data, r, field_names))

+ .collect_vec()

+}

+

+fn build_usage_edit(

+ ctx: &AssistContext<'_>,

+ builder: &mut SourceChangeBuilder,

+ data: &StructEditData,

+ usage: &FileReference,

+ field_names: &FxHashMap<SmolStr, SmolStr>,

+) -> Option<StructUsageEdit> {

+ match usage.name.syntax().ancestors().find_map(ast::FieldExpr::cast) {

+ Some(field_expr) => Some({

+ let field_name: SmolStr = field_expr.name_ref()?.to_string().into();

+ let new_field_name = field_names.get(&field_name)?;

+ let new_expr = ast::make::expr_path(ast::make::ext::ident_path(new_field_name));

+

+ // If struct binding is a reference, we might need to deref field usages

+ if data.is_ref {

+ let (replace_expr, ref_data) = determine_ref_and_parens(ctx, &field_expr);

+ StructUsageEdit::IndexField(

+ builder.make_mut(replace_expr),

+ ref_data.wrap_expr(new_expr).clone_for_update(),

+ )

+ } else {

+ StructUsageEdit::IndexField(

+ builder.make_mut(field_expr).into(),

+ new_expr.clone_for_update(),

+ )

+ }

+ }),

+ None => Some(StructUsageEdit::Path(usage.range)),

+ }

+}

+

+enum StructUsageEdit {

+ Path(TextRange),

+ IndexField(ast::Expr, ast::Expr),

+}

+

+impl StructUsageEdit {

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

+ match self {

+ StructUsageEdit::Path(target_expr) => {

+ edit.replace(target_expr, "todo!()");

+ }

+ StructUsageEdit::IndexField(target_expr, replace_with) => {

+ ted::replace(target_expr.syntax(), replace_with.syntax())

+ }

+ }

+ }

+}

+

+#[cfg(test)]

+mod tests {

+ use super::*;

+

+ use crate::tests::{check_assist, check_assist_not_applicable};

+

+ #[test]

+ fn record_struct() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo { bar: i32, baz: i32 }

+

+ fn main() {

+ let $0foo = Foo { bar: 1, baz: 2 };

+ let bar2 = foo.bar;

+ let baz2 = &foo.baz;

+

+ let foo2 = foo;

+ }

+ "#,

+ r#"

+ struct Foo { bar: i32, baz: i32 }

+

+ fn main() {

+ let Foo { bar, baz } = Foo { bar: 1, baz: 2 };

+ let bar2 = bar;

+ let baz2 = &baz;

+

+ let foo2 = todo!();

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn tuple_struct() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo(i32, i32);

+

+ fn main() {

+ let $0foo = Foo(1, 2);

+ let bar2 = foo.0;

+ let baz2 = foo.1;

+

+ let foo2 = foo;

+ }

+ "#,

+ r#"

+ struct Foo(i32, i32);

+

+ fn main() {

+ let Foo(_0, _1) = Foo(1, 2);

+ let bar2 = _0;

+ let baz2 = _1;

+

+ let foo2 = todo!();

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn unit_struct() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo;

+

+ fn main() {

+ let $0foo = Foo;

+ }

+ "#,

+ r#"

+ struct Foo;

+

+ fn main() {

+ let Foo = Foo;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn in_foreign_crate() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ //- /lib.rs crate:dep

+ pub struct Foo { pub bar: i32 };

+

+ //- /main.rs crate:main deps:dep

+ fn main() {

+ let $0foo = dep::Foo { bar: 1 };

+ let bar2 = foo.bar;

+ }

+ "#,

+ r#"

+ fn main() {

+ let dep::Foo { bar } = dep::Foo { bar: 1 };

+ let bar2 = bar;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn non_exhaustive_record_appends_rest() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ //- /lib.rs crate:dep

+ #[non_exhaustive]

+ pub struct Foo { pub bar: i32 };

+

+ //- /main.rs crate:main deps:dep

+ fn main($0foo: dep::Foo) {

+ let bar2 = foo.bar;

+ }

+ "#,

+ r#"

+ fn main(dep::Foo { bar, .. }: dep::Foo) {

+ let bar2 = bar;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn non_exhaustive_tuple_not_applicable() {

+ check_assist_not_applicable(

+ destructure_struct_binding,

+ r#"

+ //- /lib.rs crate:dep

+ #[non_exhaustive]

+ pub struct Foo(pub i32, pub i32);

+

+ //- /main.rs crate:main deps:dep

+ fn main(foo: dep::Foo) {

+ let $0foo2 = foo;

+ let bar = foo2.0;

+ let baz = foo2.1;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn non_exhaustive_unit_not_applicable() {

+ check_assist_not_applicable(

+ destructure_struct_binding,

+ r#"

+ //- /lib.rs crate:dep

+ #[non_exhaustive]

+ pub struct Foo;

+

+ //- /main.rs crate:main deps:dep

+ fn main(foo: dep::Foo) {

+ let $0foo2 = foo;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn record_private_fields_appends_rest() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ //- /lib.rs crate:dep

+ pub struct Foo { pub bar: i32, baz: i32 };

+

+ //- /main.rs crate:main deps:dep

+ fn main(foo: dep::Foo) {

+ let $0foo2 = foo;

+ let bar2 = foo2.bar;

+ }

+ "#,

+ r#"

+ fn main(foo: dep::Foo) {

+ let dep::Foo { bar, .. } = foo;

+ let bar2 = bar;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn tuple_private_fields_not_applicable() {

+ check_assist_not_applicable(

+ destructure_struct_binding,

+ r#"

+ //- /lib.rs crate:dep

+ pub struct Foo(pub i32, i32);

+

+ //- /main.rs crate:main deps:dep

+ fn main(foo: dep::Foo) {

+ let $0foo2 = foo;

+ let bar2 = foo2.0;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn nested_inside_record() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo { fizz: Fizz }

+ struct Fizz { buzz: i32 }

+

+ fn main() {

+ let Foo { $0fizz } = Foo { fizz: Fizz { buzz: 1 } };

+ let buzz2 = fizz.buzz;

+ }

+ "#,

+ r#"

+ struct Foo { fizz: Fizz }

+ struct Fizz { buzz: i32 }

+

+ fn main() {

+ let Foo { fizz: Fizz { buzz } } = Foo { fizz: Fizz { buzz: 1 } };

+ let buzz2 = buzz;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn nested_inside_tuple() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo(Fizz);

+ struct Fizz { buzz: i32 }

+

+ fn main() {

+ let Foo($0fizz) = Foo(Fizz { buzz: 1 });

+ let buzz2 = fizz.buzz;

+ }

+ "#,

+ r#"

+ struct Foo(Fizz);

+ struct Fizz { buzz: i32 }

+

+ fn main() {

+ let Foo(Fizz { buzz }) = Foo(Fizz { buzz: 1 });

+ let buzz2 = buzz;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn mut_record() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo { bar: i32, baz: i32 }

+

+ fn main() {

+ let mut $0foo = Foo { bar: 1, baz: 2 };

+ let bar2 = foo.bar;

+ let baz2 = &foo.baz;

+ }

+ "#,

+ r#"

+ struct Foo { bar: i32, baz: i32 }

+

+ fn main() {

+ let Foo { bar: mut bar, baz: mut baz } = Foo { bar: 1, baz: 2 };

+ let bar2 = bar;

+ let baz2 = &baz;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn mut_ref() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo { bar: i32, baz: i32 }

+

+ fn main() {

+ let $0foo = &mut Foo { bar: 1, baz: 2 };

+ foo.bar = 5;

+ }

+ "#,

+ r#"

+ struct Foo { bar: i32, baz: i32 }

+

+ fn main() {

+ let Foo { bar, baz } = &mut Foo { bar: 1, baz: 2 };

+ *bar = 5;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn record_struct_name_collision() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo { bar: i32, baz: i32 }

+

+ fn main(baz: i32) {

+ let bar = true;

+ let $0foo = Foo { bar: 1, baz: 2 };

+ let baz_1 = 7;

+ let bar_usage = foo.bar;

+ let baz_usage = foo.baz;

+ }

+ "#,

+ r#"

+ struct Foo { bar: i32, baz: i32 }

+

+ fn main(baz: i32) {

+ let bar = true;

+ let Foo { bar: bar_1, baz: baz_2 } = Foo { bar: 1, baz: 2 };

+ let baz_1 = 7;

+ let bar_usage = bar_1;

+ let baz_usage = baz_2;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn tuple_struct_name_collision() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo(i32, i32);

+

+ fn main() {

+ let _0 = true;

+ let $0foo = Foo(1, 2);

+ let bar = foo.0;

+ let baz = foo.1;

+ }

+ "#,

+ r#"

+ struct Foo(i32, i32);

+

+ fn main() {

+ let _0 = true;

+ let Foo(_0_1, _1) = Foo(1, 2);

+ let bar = _0_1;

+ let baz = _1;

+ }

+ "#,

+ )

+ }

+

+ #[test]

+ fn record_struct_name_collision_nested_scope() {

+ check_assist(

+ destructure_struct_binding,

+ r#"

+ struct Foo { bar: i32 }

+

+ fn main(foo: Foo) {

+ let bar = 5;

+

+ let new_bar = {

+ let $0foo2 = foo;

+ let bar_1 = 5;

+ foo2.bar

+ };

+ }

+ "#,

+ r#"

+ struct Foo { bar: i32 }

+

+ fn main(foo: Foo) {

+ let bar = 5;

+

+ let new_bar = {

+ let Foo { bar: bar_2 } = foo;

+ let bar_1 = 5;

+ bar_2

+ };

+ }

+ "#,

+ )

+ }

+}

+ ast::{self, make, AstNode, FieldExpr, HasName, IdentPat},

+ ted,

+use crate::{

+ assist_context::{AssistContext, Assists, SourceChangeBuilder},

+ utils::ref_field_expr::determine_ref_and_parens,

+};

+ let (replace_expr, ref_data) = determine_ref_and_parens(ctx, &index.field_expr);

+use syntax::{

+ ast::{self, make},

+ AstNode,

+};

+

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

+

+// Assist: fill_record_pattern_fields

+//

+// Fills fields by replacing rest pattern in record patterns.

+//

+// ```

+// struct Bar { y: Y, z: Z }

+//

+// fn foo(bar: Bar) {

+// let Bar { ..$0 } = bar;

+// }

+// ```

+// ->

+// ```

+// struct Bar { y: Y, z: Z }

+//

+// fn foo(bar: Bar) {

+// let Bar { y, z } = bar;

+// }

+// ```

+pub(crate) fn fill_record_pattern_fields(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {

+ let record_pat = ctx.find_node_at_offset::<ast::RecordPat>()?;

+

+ let ellipsis = record_pat.record_pat_field_list().and_then(|r| r.rest_pat())?;

+ if !ellipsis.syntax().text_range().contains_inclusive(ctx.offset()) {

+ return None;

+ }

+

+ let target_range = ellipsis.syntax().text_range();

+

+ let missing_fields = ctx.sema.record_pattern_missing_fields(&record_pat);

+

+ if missing_fields.is_empty() {

+ cov_mark::hit!(no_missing_fields);

+ return None;

+ }

+

+ let old_field_list = record_pat.record_pat_field_list()?;

+ let new_field_list =

+ make::record_pat_field_list(old_field_list.fields(), None).clone_for_update();

+ for (f, _) in missing_fields.iter() {

+ let field =

+ make::record_pat_field_shorthand(make::name_ref(&f.name(ctx.sema.db).to_smol_str()));

+ new_field_list.add_field(field.clone_for_update());

+ }

+

+ let old_range = ctx.sema.original_range_opt(old_field_list.syntax())?;

+ if old_range.file_id != ctx.file_id() {

+ return None;

+ }

+

+ acc.add(

+ AssistId("fill_record_pattern_fields", crate::AssistKind::RefactorRewrite),

+ "Fill structure fields",

+ target_range,

+ move |builder| builder.replace_ast(old_field_list, new_field_list),

+ )

+}

+

+#[cfg(test)]

+mod tests {

+ use super::*;

+ use crate::tests::{check_assist, check_assist_not_applicable};

+

+ #[test]

+ fn fill_fields_enum_with_only_ellipsis() {

+ check_assist(

+ fill_record_pattern_fields,

+ r#"

+enum Foo {

+ A(X),

+ B{y: Y, z: Z}

+}

+

+fn bar(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B{ ..$0 } => true,

+ };

+}

+"#,

+ r#"

+enum Foo {

+ A(X),

+ B{y: Y, z: Z}

+}

+

+fn bar(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B{ y, z } => true,

+ };

+}

+"#,

+ )

+ }

+

+ #[test]

+ fn fill_fields_enum_with_fields() {

+ check_assist(

+ fill_record_pattern_fields,

+ r#"

+enum Foo {

+ A(X),

+ B{y: Y, z: Z}

+}

+

+fn bar(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B{ y, ..$0 } => true,

+ };

+}

+"#,

+ r#"

+enum Foo {

+ A(X),

+ B{y: Y, z: Z}

+}

+

+fn bar(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B{ y, z } => true,

+ };

+}

+"#,

+ )

+ }

+

+ #[test]

+ fn fill_fields_struct_with_only_ellipsis() {

+ check_assist(

+ fill_record_pattern_fields,

+ r#"

+struct Bar {

+ y: Y,

+ z: Z,

+}

+

+fn foo(bar: Bar) {

+ let Bar { ..$0 } = bar;

+}

+"#,

+ r#"

+struct Bar {

+ y: Y,

+ z: Z,

+}

+

+fn foo(bar: Bar) {

+ let Bar { y, z } = bar;

+}

+"#,

+ )

+ }

+

+ #[test]

+ fn fill_fields_struct_with_fields() {

+ check_assist(

+ fill_record_pattern_fields,

+ r#"

+struct Bar {

+ y: Y,

+ z: Z,

+}

+

+fn foo(bar: Bar) {

+ let Bar { y, ..$0 } = bar;

+}

+"#,

+ r#"

+struct Bar {

+ y: Y,

+ z: Z,

+}

+

+fn foo(bar: Bar) {

+ let Bar { y, z } = bar;

+}

+"#,

+ )

+ }

+

+ #[test]

+ fn fill_fields_struct_generated_by_macro() {

+ check_assist(

+ fill_record_pattern_fields,

+ r#"

+macro_rules! position {

+ ($t: ty) => {

+ struct Pos {x: $t, y: $t}

+ };

+}

+

+position!(usize);

+

+fn macro_call(pos: Pos) {

+ let Pos { ..$0 } = pos;

+}

+"#,

+ r#"

+macro_rules! position {

+ ($t: ty) => {

+ struct Pos {x: $t, y: $t}

+ };

+}

+

+position!(usize);

+

+fn macro_call(pos: Pos) {

+ let Pos { x, y } = pos;

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn fill_fields_enum_generated_by_macro() {

+ check_assist(

+ fill_record_pattern_fields,

+ r#"

+macro_rules! enum_gen {

+ ($t: ty) => {

+ enum Foo {

+ A($t),

+ B{x: $t, y: $t},

+ }

+ };

+}

+

+enum_gen!(usize);

+

+fn macro_call(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B{ ..$0 } => true,

+ }

+}

+"#,

+ r#"

+macro_rules! enum_gen {

+ ($t: ty) => {

+ enum Foo {

+ A($t),

+ B{x: $t, y: $t},

+ }

+ };

+}

+

+enum_gen!(usize);

+

+fn macro_call(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B{ x, y } => true,

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn not_applicable_when_not_in_ellipsis() {

+ check_assist_not_applicable(

+ fill_record_pattern_fields,

+ r#"

+enum Foo {

+ A(X),

+ B{y: Y, z: Z}

+}

+

+fn bar(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B{..}$0 => true,

+ };

+}

+"#,

+ );

+ check_assist_not_applicable(

+ fill_record_pattern_fields,

+ r#"

+enum Foo {

+ A(X),

+ B{y: Y, z: Z}

+}

+

+fn bar(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B$0{..} => true,

+ };

+}

+"#,

+ );

+ check_assist_not_applicable(

+ fill_record_pattern_fields,

+ r#"

+enum Foo {

+ A(X),

+ B{y: Y, z: Z}

+}

+

+fn bar(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::$0B{..} => true,

+ };

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn not_applicable_when_no_missing_fields() {

+ // This is still possible even though it's meaningless

+ cov_mark::check!(no_missing_fields);

+ check_assist_not_applicable(

+ fill_record_pattern_fields,

+ r#"

+enum Foo {

+ A(X),

+ B{y: Y, z: Z}

+}

+

+fn bar(foo: Foo) {

+ match foo {

+ Foo::A(_) => false,

+ Foo::B{y, z, ..$0} => true,

+ };

+}

+"#,

+ );

+ check_assist_not_applicable(

+ fill_record_pattern_fields,

+ r#"

+struct Bar {

+ y: Y,

+ z: Z,

+}

+

+fn foo(bar: Bar) {

+ let Bar { y, z, ..$0 } = bar;

+}

+"#,

+ );

+ }

+}

+ // FIXME: do not handle callsites in macros' parameters, because

+ // directly inlining into macros may cause errors.

+ .filter(|call_info| !ctx.sema.hir_file_for(call_info.node.syntax()).is_macro())

+

+ #[test]

+ fn inline_into_callers_in_macros_not_applicable() {

+ check_assist_not_applicable(

+ inline_into_callers,

+ r#"

+fn foo() -> u32 {

+ 42

+}

+

+macro_rules! bar {

+ ($x:expr) => {

+ $x

+ };

+}

+

+fn f() {

+ bar!(foo$0());

+}

+"#,

+ );

+ }

+ let macro_name = macro_call.name(ctx.sema.db);

+ let macro_name = macro_name.display(ctx.sema.db);

+

+ format!("Replace {macro_name}!() with {code}"),

+

+ #[test]

+ fn test_tuple_simple() {

+ check_assist(

+ term_search,

+ r#"//- minicore: todo, unimplemented

+fn f() { let a = 1; let b = 0.0; let c: (i32, f64) = todo$0!(); }"#,

+ r#"fn f() { let a = 1; let b = 0.0; let c: (i32, f64) = (a, b); }"#,

+ )

+ }

+

+ #[test]

+ fn test_tuple_nested() {

+ check_assist(

+ term_search,

+ r#"//- minicore: todo, unimplemented

+fn f() { let a = 1; let b = 0.0; let c: (i32, (i32, f64)) = todo$0!(); }"#,

+ r#"fn f() { let a = 1; let b = 0.0; let c: (i32, (i32, f64)) = (a, (a, b)); }"#,

+ )

+ }

+ mod destructure_struct_binding;

+ mod fill_record_pattern_fields;

+ destructure_struct_binding::destructure_struct_binding,

+ fill_record_pattern_fields::fill_record_pattern_fields,

+fn doctest_destructure_struct_binding() {

+ check_doc_test(

+ "destructure_struct_binding",

+ r#####"

+struct Foo {

+ bar: i32,

+ baz: i32,

+}

+fn main() {

+ let $0foo = Foo { bar: 1, baz: 2 };

+ let bar2 = foo.bar;

+ let baz2 = &foo.baz;

+}

+"#####,

+ r#####"

+struct Foo {

+ bar: i32,

+ baz: i32,

+}

+fn main() {

+ let Foo { bar, baz } = Foo { bar: 1, baz: 2 };

+ let bar2 = bar;

+ let baz2 = &baz;

+}

+"#####,

+ )

+}

+

+#[test]

+fn doctest_fill_record_pattern_fields() {

+ check_doc_test(

+ "fill_record_pattern_fields",

+ r#####"

+struct Bar { y: Y, z: Z }

+

+fn foo(bar: Bar) {

+ let Bar { ..$0 } = bar;

+}

+"#####,

+ r#####"

+struct Bar { y: Y, z: Z }

+

+fn foo(bar: Bar) {

+ let Bar { y, z } = bar;

+}

+"#####,

+ )

+}

+

+#[test]

+pub(crate) mod ref_field_expr;

+ let list = make::record_pat_field_list(fields, None);

+//! This module contains a helper for converting a field access expression into a

+//! path expression. This is used when destructuring a tuple or struct.

+//!

+//! It determines whether to deref the new expression and/or wrap it in parentheses,

+//! based on the parent of the existing expression.

+use syntax::{

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

+ AstNode, T,

+};

+

+use crate::AssistContext;

+

+/// Decides whether the new path expression needs to be dereferenced and/or wrapped in parens.

+/// Returns the relevant parent expression to replace and the [RefData].

+pub(crate) fn determine_ref_and_parens(

+ ctx: &AssistContext<'_>,

+ field_expr: &FieldExpr,

+) -> (ast::Expr, RefData) {

+ let s = field_expr.syntax();

+ let mut ref_data = RefData { needs_deref: true, needs_parentheses: true };

+ let mut target_node = field_expr.clone().into();

+

+ let parent = match s.parent().map(ast::Expr::cast) {

+ Some(Some(parent)) => parent,

+ Some(None) => {

+ ref_data.needs_parentheses = false;

+ return (target_node, ref_data);

+ }

+ None => return (target_node, ref_data),

+ };

+

+ match parent {

+ ast::Expr::ParenExpr(it) => {

+ // already parens in place -> don't replace

+ ref_data.needs_parentheses = false;

+ // there might be a ref outside: `&(t.0)` -> can be removed

+ if let Some(it) = it.syntax().parent().and_then(ast::RefExpr::cast) {

+ ref_data.needs_deref = false;

+ target_node = it.into();

+ }

+ }

+ ast::Expr::RefExpr(it) => {

+ // `&*` -> cancel each other out

+ ref_data.needs_deref = false;

+ ref_data.needs_parentheses = false;

+ // might be surrounded by parens -> can be removed too

+ match it.syntax().parent().and_then(ast::ParenExpr::cast) {

+ Some(parent) => target_node = parent.into(),

+ None => target_node = it.into(),

+ };

+ }

+ // higher precedence than deref `*`

+ // https://doc.rust-lang.org/reference/expressions.html#expression-precedence

+ // -> requires parentheses

+ ast::Expr::PathExpr(_it) => {}

+ ast::Expr::MethodCallExpr(it) => {

+ // `field_expr` is `self_param` (otherwise it would be in `ArgList`)

+

+ // test if there's already auto-ref in place (`value` -> `&value`)

+ // -> no method accepting `self`, but `&self` -> no need for deref

+ //

+ // other combinations (`&value` -> `value`, `&&value` -> `&value`, `&value` -> `&&value`) might or might not be able to auto-ref/deref,

+ // but there might be trait implementations an added `&` might resolve to

+ // -> ONLY handle auto-ref from `value` to `&value`

+ fn is_auto_ref(ctx: &AssistContext<'_>, call_expr: &MethodCallExpr) -> bool {

+ fn impl_(ctx: &AssistContext<'_>, call_expr: &MethodCallExpr) -> Option<bool> {

+ let rec = call_expr.receiver()?;

+ let rec_ty = ctx.sema.type_of_expr(&rec)?.original();

+ // input must be actual value

+ if rec_ty.is_reference() {

+ return Some(false);

+ }

+

+ // doesn't resolve trait impl

+ let f = ctx.sema.resolve_method_call(call_expr)?;

+ let self_param = f.self_param(ctx.db())?;

+ // self must be ref

+ match self_param.access(ctx.db()) {

+ hir::Access::Shared | hir::Access::Exclusive => Some(true),

+ hir::Access::Owned => Some(false),

+ }

+ }

+ impl_(ctx, call_expr).unwrap_or(false)

+ }

+

+ if is_auto_ref(ctx, &it) {

+ ref_data.needs_deref = false;

+ ref_data.needs_parentheses = false;

+ }

+ }

+ ast::Expr::FieldExpr(_it) => {

+ // `t.0.my_field`

+ ref_data.needs_deref = false;

+ ref_data.needs_parentheses = false;

+ }

+ ast::Expr::IndexExpr(_it) => {

+ // `t.0[1]`

+ ref_data.needs_deref = false;

+ ref_data.needs_parentheses = false;

+ }

+ ast::Expr::TryExpr(_it) => {

+ // `t.0?`

+ // requires deref and parens: `(*_0)`

+ }

+ // lower precedence than deref `*` -> no parens

+ _ => {

+ ref_data.needs_parentheses = false;

+ }

+ };

+

+ (target_node, ref_data)

+}

+

+/// Indicates whether to deref an expression or wrap it in parens

+pub(crate) struct RefData {

+ needs_deref: bool,

+ needs_parentheses: bool,

+}

+

+impl RefData {

+ /// Derefs `expr` and wraps it in parens if necessary

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

+ if self.needs_deref {

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

+ }

+

+ if self.needs_parentheses {

+ expr = make::expr_paren(expr);

+ }

+

+ expr

+ }

+}

+ // buggy

+ ex Foo::B [type]

+fn trait_method_fuzzy_completion_aware_of_fundamental_boxes() {

+ let fixture = r#"

+//- /fundamental.rs crate:fundamental

+#[lang = "owned_box"]

+#[fundamental]

+pub struct Box<T>(T);

+//- /foo.rs crate:foo

+pub trait TestTrait {

+ fn some_method(&self);

+}

+//- /main.rs crate:main deps:foo,fundamental

+struct TestStruct;

+

+impl foo::TestTrait for fundamental::Box<TestStruct> {

+ fn some_method(&self) {}

+}

+

+fn main() {

+ let t = fundamental::Box(TestStruct);

+ t.$0

+}

+"#;

+

+ check(

+ fixture,

+ expect![[r#"

+ me some_method() (use foo::TestTrait) fn(&self)

+ "#]],

+ );

+

+ check_edit(

+ "some_method",

+ fixture,

+ r#"

+use foo::TestTrait;

+

+struct TestStruct;

+

+impl foo::TestTrait for fundamental::Box<TestStruct> {

+ fn some_method(&self) {}

+}

+

+fn main() {

+ let t = fundamental::Box(TestStruct);

+ t.some_method()$0

+}

+"#,

+ );

+}

+

+#[test]

+fn trait_method_fuzzy_completion_aware_of_fundamental_references() {

+ let fixture = r#"

+//- /foo.rs crate:foo

+pub trait TestTrait {

+ fn some_method(&self);

+}

+//- /main.rs crate:main deps:foo

+struct TestStruct;

+

+impl foo::TestTrait for &TestStruct {

+ fn some_method(&self) {}

+}

+

+fn main() {

+ let t = &TestStruct;

+ t.$0

+}

+"#;

+

+ check(

+ fixture,

+ expect![[r#"

+ me some_method() (use foo::TestTrait) fn(&self)

+ "#]],

+ );

+

+ check_edit(

+ "some_method",

+ fixture,

+ r#"

+use foo::TestTrait;

+

+struct TestStruct;

+

+impl foo::TestTrait for &TestStruct {

+ fn some_method(&self) {}

+}

+

+fn main() {

+ let t = &TestStruct;

+ t.some_method()$0

+}

+"#,

+ );

+}

+

+#[test]

+fn trait_method_fuzzy_completion_aware_of_unit_type() {

+ let fixture = r#"

+//- /test_trait.rs crate:test_trait

+pub trait TestInto<T> {

+ fn into(self) -> T;

+}

+

+//- /main.rs crate:main deps:test_trait

+struct A;

+

+impl test_trait::TestInto<A> for () {

+ fn into(self) -> A {

+ A

+ }

+}

+

+fn main() {

+ let a = ();

+ a.$0

+}

+"#;

+

+ check(

+ fixture,

+ expect![[r#"

+ me into() (use test_trait::TestInto) fn(self) -> T

+ "#]],

+ );

+}

+

+#[test]

+crossbeam-channel = "0.5.5"

+workspace = true

+ GenericParam, Label, Macro, ExternCrateDecl

+ db::HirDatabase, AsAssocItem, AssocItem, AssocItemContainer, Crate, HasCrate, ItemInNs,

+ ModPath, Module, ModuleDef, Name, PathResolution, PrefixKind, ScopeDef, Semantics,

+ SemanticsScope, Trait, Type,

+ let mut trait_candidates: FxHashSet<_> = items_locator::items_with_name(

+ trait_candidates.retain(|&candidate_trait_id| {

+ // we care about the following cases:

+ // 1. Trait's definition crate

+ // 2. Definition crates for all trait's generic arguments

+ // a. This is recursive for fundamental types: `Into<Box<A>> for ()`` is OK, but

+ // `Into<Vec<A>> for ()`` is *not*.

+ // 3. Receiver type definition crate

+ // a. This is recursive for fundamental types

+ let defining_crate_for_trait = Trait::from(candidate_trait_id).krate(db);

+ let Some(receiver) = trait_candidate.receiver_ty.fingerprint_for_trait_impl() else {

+ return false;

+ };

+ let definitions_exist_in_trait_crate = db

+ .trait_impls_in_crate(defining_crate_for_trait.into())

+ .has_impls_for_trait_and_self_ty(candidate_trait_id, receiver);

+

+ // this is a closure for laziness: if `definitions_exist_in_trait_crate` is true,

+ // we can avoid a second db lookup.

+ let definitions_exist_in_receiver_crate = || {

+ db.trait_impls_in_crate(trait_candidate.receiver_ty.krate(db).into())

+ .has_impls_for_trait_and_self_ty(candidate_trait_id, receiver)

+ };

+

+ definitions_exist_in_trait_crate || definitions_exist_in_receiver_crate()

+ });

+

+pub mod prime_caches;

+

+use crate::{

+ FxHashSet, FxIndexMap, RootDatabase,

+pub fn parallel_prime_caches(

+ .name("PrimeCaches".to_owned())

+use crate::FxHashMap;

+ fn replace_filter_map_next_dont_work_for_not_sized_issues_16596() {

+ check_diagnostics(

+ r#"

+//- minicore: iterators

+fn foo() {

+ let mut j = [0].into_iter();

+ let i: &mut dyn Iterator<Item = i32> = &mut j;

+ let dummy_fn = |v| (v > 0).then_some(v + 1);

+ let _res = i.filter_map(dummy_fn).next();

+}

+"#,

+ );

+ }

+

+ #[test]

+ // FIXME: This should show a diagnostic

+ #[test]

+ fn feature() {

+ check_diagnostics(

+ r#"

+//- minicore: fmt

+fn main() {

+ format_args!("{unresolved}");

+}

+"#,

+ )

+ }

+

+workspace = true

+ ast::SourceFile(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::Module(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::Fn(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::Struct(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(hir::Adt::Struct(def)))),

+ ast::Union(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(hir::Adt::Union(def)))),

+ ast::Enum(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(hir::Adt::Enum(def)))),

+ ast::Variant(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::Trait(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::Static(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::Const(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::TypeAlias(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::Impl(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::RecordField(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::TupleField(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::Macro(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+ ast::ExternCrate(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::from(def))),

+const TYPES: (&[&str], &[&str]) =

+ (&["type", "struct", "enum", "mod", "trait", "union", "module", "prim", "primitive"], &[]);

+const VALUES: (&[&str], &[&str]) =

+ (&["value", "function", "fn", "method", "const", "static", "mod", "module"], &["()"]);

+const MACROS: (&[&str], &[&str]) = (&["macro", "derive"], &["!"]);

+ (hir::Namespace::Types, TYPES),

+ (hir::Namespace::Values, VALUES),

+ (hir::Namespace::Macros, MACROS),

+ .find_map(|(ns, (prefixes, suffixes))| {

+ if let Some(prefix) = prefixes.iter().find(|&&prefix| {

+ suffixes.iter().find_map(|&suffix| s.strip_suffix(suffix).zip(Some(ns)))

+ [TYPES, VALUES, MACROS]

+ .into_iter()

+ .find_map(|(prefixes, suffixes)| {

+ if let Some(prefix) = prefixes.iter().find(|&&prefix| {

+ s.starts_with(prefix)

+ && s.chars().nth(prefix.len()).map_or(false, |c| c == '@' || c == ' ')

+ }) {

+ Some(&s[prefix.len() + 1..])

+ } else {

+ suffixes.iter().find_map(|&suffix| s.strip_suffix(suffix))

+ }

+ })

+ .unwrap_or(s)

+ fn goto_index_mut_op() {

+ check(

+ r#"

+//- minicore: index

+

+struct Foo;

+struct Bar;

+

+impl core::ops::Index<usize> for Foo {

+ type Output = Bar;

+

+ fn index(&self, index: usize) -> &Self::Output {}

+}

+

+impl core::ops::IndexMut<usize> for Foo {

+ fn index_mut(&mut self, index: usize) -> &mut Self::Output {}

+ //^^^^^^^^^

+}

+

+fn f() {

+ let mut foo = Foo;

+ foo[0]$0 = Bar;

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn goto_deref_mut() {

+ check(

+ r#"

+//- minicore: deref, deref_mut

+

+struct Foo;

+struct Bar;

+

+impl core::ops::Deref for Foo {

+ type Target = Bar;

+ fn deref(&self) -> &Self::Target {}

+}

+

+impl core::ops::DerefMut for Foo {

+ fn deref_mut(&mut self) -> &mut Self::Target {}

+ //^^^^^^^^^

+}

+

+fn f() {

+ let a = Foo;

+ $0*a = Bar;

+}

+"#,

+ );

+ }

+

+ #[test]

+ }).zip(Some(true)),

+ }).zip(Some(false)),

+ if let Some((trait_item_use_scope, use_tree)) = trait_item_use_scope {

+ if use_tree { t.items(sema.db) } else { t.items_with_supertraits(sema.db) }

+trait Super {

+ type SuperT;

+}

+trait Foo: Super {

+ let _: T::SuperT;

+ //^^^^^^

+ fn test_trait_highlights_assoc_item_uses_use_tree() {

+ check(

+ r#"

+use Foo$0;

+ // ^^^ import

+trait Super {

+ type SuperT;

+}

+trait Foo: Super {

+ //^^^

+ type T;

+ const C: usize;

+ fn f() {}

+ fn m(&self) {}

+}

+impl Foo for i32 {

+ //^^^

+ type T = i32;

+ // ^

+ const C: usize = 0;

+ // ^

+ fn f() {}

+ // ^

+ fn m(&self) {}

+ // ^

+}

+fn f<T: Foo>(t: T) {

+ //^^^

+ let _: T::SuperT;

+ let _: T::T;

+ //^

+ t.m();

+ //^

+ T::C;

+ //^

+ T::f();

+ //^

+}

+"#,

+ );

+ }

+

+ #[test]

+fn hover_intra_generics() {

+ check(

+ r#"

+/// Doc comment for [`Foo$0<T>`]

+pub struct Foo<T>(T);

+"#,

+ expect![[r#"

+ *[`Foo<T>`]*

+

+ ```rust

+ test

+ ```

+

+ ```rust

+ pub struct Foo<T>(T);

+ ```

+

+ ---

+

+ Doc comment for [`Foo<T>`](https://docs.rs/test/*/test/struct.Foo.html)

+ "#]],

+ );

+}

+

+#[test]

+ prime_caches, symbol_index, FxHashMap, FxIndexSet, LineIndexDatabase,

+ prime_caches::ParallelPrimeCachesProgress,

+ pub fn with_database(db: RootDatabase) -> AnalysisHost {

+ AnalysisHost { db }

+ }

+

+use core::fmt;

+

+impl fmt::Display for MonikerIdentifier {

+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

+ f.write_str(&self.crate_name)?;

+ f.write_fmt(format_args!("::{}", self.description.iter().map(|x| &x.name).join("::")))

+ use ide_db::FxHasher;

+ use std::hash::Hasher;

+

+ let mut hasher = FxHasher::default();

+

+<style>

+body { margin: 0; }

+pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }

+

+.lifetime { color: #DFAF8F; font-style: italic; }

+.label { color: #DFAF8F; font-style: italic; }

+.comment { color: #7F9F7F; }

+.documentation { color: #629755; }

+.intra_doc_link { font-style: italic; }

+.injected { opacity: 0.65 ; }

+.struct, .enum { color: #7CB8BB; }

+.enum_variant { color: #BDE0F3; }

+.string_literal { color: #CC9393; }

+.field { color: #94BFF3; }

+.function { color: #93E0E3; }

+.function.unsafe { color: #BC8383; }

+.trait.unsafe { color: #BC8383; }

+.operator.unsafe { color: #BC8383; }

+.mutable.unsafe { color: #BC8383; text-decoration: underline; }

+.keyword.unsafe { color: #BC8383; font-weight: bold; }

+.macro.unsafe { color: #BC8383; }

+.parameter { color: #94BFF3; }

+.text { color: #DCDCCC; }

+.type { color: #7CB8BB; }

+.builtin_type { color: #8CD0D3; }

+.type_param { color: #DFAF8F; }

+.attribute { color: #94BFF3; }

+.numeric_literal { color: #BFEBBF; }

+.bool_literal { color: #BFE6EB; }

+.macro { color: #94BFF3; }

+.derive { color: #94BFF3; font-style: italic; }

+.module { color: #AFD8AF; }

+.value_param { color: #DCDCCC; }

+.variable { color: #DCDCCC; }

+.format_specifier { color: #CC696B; }

+.mutable { text-decoration: underline; }

+.escape_sequence { color: #94BFF3; }

+.keyword { color: #F0DFAF; font-weight: bold; }

+.control { font-style: italic; }

+.reference { font-style: italic; font-weight: bold; }

+

+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }

+.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }

+</style>

+<pre><code><span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration">foo</span> <span class="brace">{</span>

+ <span class="parenthesis">(</span><span class="punctuation">$</span>foo<span class="colon">:</span>ident<span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span>

+ <span class="keyword">mod</span> y <span class="brace">{</span>

+ <span class="keyword">struct</span> <span class="punctuation">$</span>foo<span class="semicolon">;</span>

+ <span class="brace">}</span>

+ <span class="brace">}</span><span class="semicolon">;</span>

+<span class="brace">}</span>

+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>

+ <span class="macro">foo</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="struct declaration macro">Foo</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

+ <span class="keyword">mod</span> <span class="module declaration">module</span> <span class="brace">{</span>

+ <span class="comment">// FIXME: IDE layer has this unresolved</span>

+ <span class="unresolved_reference">foo</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="none macro">Bar</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

+ <span class="keyword">fn</span> <span class="function declaration">func</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>

+ <span class="keyword">mod</span> <span class="module declaration">inner</span> <span class="brace">{</span>

+ <span class="keyword">struct</span> <span class="struct declaration">Innerest</span><span class="angle">&lt;</span><span class="keyword">const</span> <span class="const_param declaration">C</span><span class="colon">:</span> <span class="unresolved_reference">usize</span><span class="angle">&gt;</span> <span class="brace">{</span> <span class="field declaration">field</span><span class="colon">:</span> <span class="bracket">[</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span> <span class="brace">{</span><span class="const_param">C</span><span class="brace">}</span><span class="bracket">]</span> <span class="brace">}</span>

+ <span class="brace">}</span>

+ <span class="brace">}</span>

+ <span class="brace">}</span>

+<span class="brace">}</span></code></pre> \ No newline at end of file

+ <span class="keyword">let</span> <span class="variable declaration reference" data-binding-hash="8384512769119783714" style="color: hsl(59,93%,58%);">hello</span> <span class="operator">=</span> <span class="string_literal">"hello"</span><span class="semicolon">;</span>

+ <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="17360984456076382725" style="color: hsl(95,79%,86%);">x</span> <span class="operator">=</span> <span class="variable reference" data-binding-hash="8384512769119783714" style="color: hsl(59,93%,58%);">hello</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>

+ <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="17186414787327620935" style="color: hsl(196,64%,89%);">y</span> <span class="operator">=</span> <span class="variable reference" data-binding-hash="8384512769119783714" style="color: hsl(59,93%,58%);">hello</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>

+ <span class="keyword">let</span> <span class="variable declaration reference" data-binding-hash="4786021388930833562" style="color: hsl(137,61%,87%);">x</span> <span class="operator">=</span> <span class="string_literal">"other color please!"</span><span class="semicolon">;</span>

+ <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="18017815841345165192" style="color: hsl(39,76%,89%);">y</span> <span class="operator">=</span> <span class="variable reference" data-binding-hash="4786021388930833562" style="color: hsl(137,61%,87%);">x</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>

+ <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable reference" data-binding-hash="8384512769119783714" style="color: hsl(59,93%,58%);">hello</span> <span class="operator">=</span> <span class="string_literal">"hello"</span><span class="semicolon">;</span>

+fn test_block_mod_items() {

+ check_highlighting(

+ r#"

+macro_rules! foo {

+ ($foo:ident) => {

+ mod y {

+ struct $foo;

+ }

+ };

+}

+fn main() {

+ foo!(Foo);

+ mod module {

+ // FIXME: IDE layer has this unresolved

+ foo!(Bar);

+ fn func() {

+ mod inner {

+ struct Innerest<const C: usize> { field: [(); {C}] }

+ }

+ }

+ }

+}

+"#,

+ expect_file!["./test_data/highlight_block_mod_items.html"],

+ false,

+ );

+}

+

+#[test]

+# workspace deps

+

+hir-expand.workspace = true

+span.workspace = true

+vfs.workspace = true

+workspace = true

+ base_db::{CrateGraph, Env, SourceRoot},

+ prime_caches, Change, FxHashMap, RootDatabase,

+) -> anyhow::Result<(RootDatabase, vfs::Vfs, Option<ProcMacroServer>)> {

+) -> anyhow::Result<(RootDatabase, vfs::Vfs, Option<ProcMacroServer>)> {

+ let db = load_crate_graph(

+ prime_caches::parallel_prime_caches(&db, 1, &|_| ());

+ Ok((db, vfs, proc_macro_server.ok()))

+) -> RootDatabase {

+ let mut db = RootDatabase::new(lru_cap);

+ db.enable_proc_attr_macros();

+ db.apply_change(analysis_change);

+ db

+ let (db, _vfs, _proc_macro) =

+ let n_crates = db.crate_graph().iter().count();

+

+ /// Equivalent of [`Path::to_path_buf`] for `RelPath`.

+ pub fn to_path_buf(&self) -> RelPathBuf {

+ RelPathBuf::try_from(self.0.to_path_buf()).unwrap()

+ }

+/// Invokes the callback with a `&[&str]` consisting of each part of the

+/// literal's representation. This is done to allow the `ToString` and

+/// `Display` implementations to borrow references to symbol values, and

+/// both be optimized to reduce overhead.

+fn literal_with_stringify_parts<S, R>(

+ literal: &bridge::Literal<S, Symbol>,

+ interner: SymbolInternerRef,

+ f: impl FnOnce(&[&str]) -> R,

+) -> R {

+ /// Returns a string containing exactly `num` '#' characters.

+ /// Uses a 256-character source string literal which is always safe to

+ /// index with a `u8` index.

+ fn get_hashes_str(num: u8) -> &'static str {

+ const HASHES: &str = "\

+ const _: () = assert!(HASHES.len() == 256);

+ &HASHES[..num as usize]

+ }

+ {

+ let symbol = &*literal.symbol.text(interner);

+ let suffix = &*literal.suffix.map(|s| s.text(interner)).unwrap_or_default();

+ match literal.kind {

+ }

+ delim_to_external, delim_to_internal, literal_with_stringify_parts,

+ token_stream::TokenStreamBuilder, Symbol, SymbolInternerRef, SYMBOL_INTERNER,

+ let text = literal_with_stringify_parts(&literal, self.interner, |parts| {

+ let literal = tt::Literal { text, span: literal.span };

+ bridge::TokenTree::Ident(match ident.text.strip_prefix("r#") {

+ Some(text) => bridge::Ident {

+ sym: Symbol::intern(self.interner, text),

+ is_raw: true,

+ span: ident.span,

+ },

+ None => bridge::Ident {

+ sym: Symbol::intern(self.interner, &ident.text),

+ is_raw: false,

+ span: ident.span,

+ },

+ // FIXME

+ // FIXME

+ // FIXME, quote is incompatible with third-party tools

+ // This is called by the quote proc-macro which is expanded when the proc-macro is compiled

+ // As such, r-a will never observe this

+ // FIXME, quote is incompatible with third-party tools

+ // This is called by the expansion of quote!, r-a will observe this, but we don't have

+ // access to the spans that were encoded

+ delim_to_external, delim_to_internal, literal_with_stringify_parts,

+ token_stream::TokenStreamBuilder, Symbol, SymbolInternerRef, SYMBOL_INTERNER,

+ let text = literal_with_stringify_parts(&literal, self.interner, |parts| {

+ let literal = tt::Literal { text, span: literal.span };

+

+ let mut cmd = Sysroot::rustc(sysroot);

+ let mut rustc = Sysroot::rustc(sysroot);

+ let mut cmd = Sysroot::rustc(sysroot);

+ /// Returns a `Command` that is configured to run `rustc` from the sysroot if it exists,

+ /// otherwise returns what [toolchain::Tool::Rustc] returns.

+ pub fn rustc(sysroot: Option<&Self>) -> Command {

+ let mut cmd = Command::new(match sysroot {

+ Some(sysroot) => {

+ toolchain::Tool::Rustc.path_in_or_discover(sysroot.root.join("bin").as_ref())

+ }

+ None => toolchain::Tool::Rustc.path(),

+ });

+ Self::set_rustup_toolchain_env(&mut cmd, sysroot);

+ cmd

+ }

+

+ let mut cmd = Sysroot::rustc(sysroot);

+ mut cmd: Command,

+ {

+ let mut cmd = Command::new(toolchain::Tool::Cargo.path());

+ Sysroot::set_rustup_toolchain_env(&mut cmd, sysroot_ref);

+ cmd

+ },

+ Sysroot::rustc(sysroot_ref),

+ Sysroot::rustc(sysroot_ref),

+ Analysis, AnalysisHost, AnnotationConfig, DiagnosticsConfig, InlayFieldsToResolve,

+ InlayHintsConfig, LineCol, RootDatabase,

+ let (db, vfs, _proc_macro) =

+ let host = AnalysisHost::with_database(db);

+ let db = host.raw_database();

+

+ "0282" | "0283" => continue, // Byproduct of testing method

+ "0277" | "0308" if generated.contains(&todo) => continue, // See https://github.com/rust-lang/rust/issues/69882

+ // FIXME: In some rare cases `AssocItem::container_or_implemented_trait` returns `None` for trait methods.

+ // Generated code is valid in case traits are imported

+ "0599" if err.contains("the following trait is implemented but not in scope") => continue,

+use ide::{AnalysisHost, AssistResolveStrategy, DiagnosticsConfig, Severity};

+ let (db, _vfs, _proc_macro) =

+ let host = AnalysisHost::with_database(db);

+ Analysis, AnalysisHost, FileId, FileRange, MonikerKind, PackageInformation, RootDatabase,

+ StaticIndex, StaticIndexedFile, TokenId, TokenStaticData,

+ let (db, vfs, _proc_macro) =

+ let host = AnalysisHost::with_database(db);

+ let (ref db, _vfs, _proc_macro) =

+ let (db, _vfs, _proc_macro) =

+ let host = AnalysisHost::with_database(db);

+ AnalysisHost, LineCol, MonikerDescriptorKind, MonikerResult, StaticIndex, StaticIndexedFile,

+ let (db, vfs, _) = load_workspace_at(

+ let host = AnalysisHost::with_database(db);

+ use ide::{FilePosition, TextSize};

+ let (ref db, vfs, _proc_macro) = load_workspace_at(