+name = "cargo-util-schemas"

+version = "0.8.2"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "7dc1a6f7b5651af85774ae5a34b4e8be397d9cf4bc063b7e6dbd99a841837830"

+dependencies = [

+ "semver",

+ "serde",

+ "serde-untagged",

+ "serde-value",

+ "thiserror 2.0.12",

+ "toml",

+ "unicode-xid",

+ "url",

+]

+

+[[package]]

+ "cargo-util-schemas 0.2.0",

+ "semver",

+ "serde",

+ "serde_json",

+ "thiserror 2.0.12",

+]

+

+[[package]]

+name = "cargo_metadata"

+version = "0.21.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "5cfca2aaa699835ba88faf58a06342a314a950d2b9686165e038286c30316868"

+dependencies = [

+ "camino",

+ "cargo-platform",

+ "cargo-util-schemas 0.8.2",

+ "anyhow",

+ "rustc-hash 2.1.1",

+ "toolchain",

+ "rustc-literal-escaper",

+ "cargo_metadata 0.20.0",

+ "cargo_metadata 0.21.0",

+version = "0.121.0"

+checksum = "3ee51482d1c9d3e538acda8cce723db8eea1a81540544bf362bf4c3d841b2329"

+version = "0.121.0"

+checksum = "19c8f1e0c28e24e1b4c55dc08058c6c9829df2204497d4034259f491d348c204"

+version = "0.121.0"

+checksum = "5f33f429cec6b92fa2c7243883279fb29dd233fdc3e94099aff32aa91aa87f50"

+version = "0.121.0"

+checksum = "b9b55910dbe1fe7ef34bdc1d1bcb41e99b377eb680ea58a1218d95d6b4152257"

+version = "0.121.0"

+checksum = "22944e31fb91e9b3e75bcbc91e37d958b8c0825a6160927f2856831d2ce83b36"

+version = "0.121.0"

+checksum = "81057891bc2063ad9e353f29462fbc47a0f5072560af34428ae9313aaa5e9d97"

+ "rustc-literal-escaper",

+version = "0.121.0"

+checksum = "fe21a3542980d56d2435e96c2720773cac1c63fd4db666417e414729da192eb3"

+ "cargo_metadata 0.21.0",

+ "rustc-literal-escaper",

+rust-version = "1.88"

+ra-ap-rustc_lexer = { version = "0.121", default-features = false }

+ra-ap-rustc_parse_format = { version = "0.121", default-features = false }

+ra-ap-rustc_index = { version = "0.121", default-features = false }

+ra-ap-rustc_abi = { version = "0.121", default-features = false }

+ra-ap-rustc_pattern_analysis = { version = "0.121", default-features = false }

+cargo_metadata = "0.21.0"

+salsa = { version = "0.23.0", default-features = true, features = [

+ "rayon",

+ "salsa_unstable",

+ "macros",

+] }

+use thin_vec::ThinVec;

+// We split the store into types-only and expressions, because most stores (e.g. generics)

+// don't store any expressions and this saves memory. Same thing for the source map.

+struct ExpressionOnlyStore {

+ exprs: Arena<Expr>,

+ pats: Arena<Pat>,

+ bindings: Arena<Binding>,

+ labels: Arena<Label>,

+ binding_owners: FxHashMap<BindingId, ExprId>,

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

+pub struct ExpressionStore {

+ expr_only: Option<Box<ExpressionOnlyStore>>,

+ pub types: Arena<TypeRef>,

+ pub lifetimes: Arena<LifetimeRef>,

+}

+

+struct ExpressionOnlySourceMap {

+ expansions: FxHashMap<InFile<MacroCallPtr>, MacroCallId>,

+ //

+ // We store diagnostics on the `ExpressionOnlySourceMap` because diagnostics are rare (except

+ // maybe for cfgs, and they are also not common in type places).

+ diagnostics: ThinVec<ExpressionStoreDiagnostics>,

+impl PartialEq for ExpressionOnlySourceMap {

+#[derive(Debug, Eq, Default)]

+pub struct ExpressionStoreSourceMap {

+ expr_only: Option<Box<ExpressionOnlySourceMap>>,

+

+ types_map_back: ArenaMap<TypeRefId, TypeSource>,

+ types_map: FxHashMap<TypeSource, TypeRefId>,

+

+ lifetime_map_back: ArenaMap<LifetimeRefId, LifetimeSource>,

+ #[expect(

+ unused,

+ reason = "this is here for completeness, and maybe we'll need it in the future"

+ )]

+ lifetime_map: FxHashMap<LifetimeSource, LifetimeRefId>,

+}

+

+impl PartialEq for ExpressionStoreSourceMap {

+ fn eq(&self, other: &Self) -> bool {

+ // we only need to compare one of the two mappings

+ // as the other is a reverse mapping and thus will compare

+ // the same as normal mapping

+ let Self { expr_only, types_map_back, types_map: _, lifetime_map_back, lifetime_map: _ } =

+ self;

+ *expr_only == other.expr_only

+ && *types_map_back == other.types_map_back

+ && *lifetime_map_back == other.lifetime_map_back

+ }

+}

+

+

+ // AST expressions can create patterns in destructuring assignments. Therefore, `ExprSource` can also map

+ // to `PatId`, and `PatId` can also map to `ExprSource` (the other way around is unaffected).

+ expr_map: FxHashMap<ExprSource, ExprOrPatId>,

+ expr_map_back: ArenaMap<ExprId, ExprOrPatSource>,

+

+ pat_map: FxHashMap<PatSource, ExprOrPatId>,

+ pat_map_back: ArenaMap<PatId, ExprOrPatSource>,

+

+ label_map: FxHashMap<LabelSource, LabelId>,

+ label_map_back: ArenaMap<LabelId, LabelSource>,

+

+ types_map_back: ArenaMap<TypeRefId, TypeSource>,

+ types_map: FxHashMap<TypeSource, TypeRefId>,

+

+ lifetime_map_back: ArenaMap<LifetimeRefId, LifetimeSource>,

+ lifetime_map: FxHashMap<LifetimeSource, LifetimeRefId>,

+

+ binding_definitions:

+ ArenaMap<BindingId, SmallVec<[PatId; 2 * size_of::<usize>() / size_of::<PatId>()]>>,

+

+ /// We don't create explicit nodes for record fields (`S { record_field: 92 }`).

+ /// Instead, we use id of expression (`92`) to identify the field.

+ field_map_back: FxHashMap<ExprId, FieldSource>,

+ pat_field_map_back: FxHashMap<PatId, PatFieldSource>,

+

+ template_map: Option<Box<FormatTemplate>>,

+

+ expansions: FxHashMap<InFile<MacroCallPtr>, MacroCallId>,

+

+ /// Diagnostics accumulated during lowering. These contain `AstPtr`s and so are stored in

+ /// the source map (since they're just as volatile).

+ //

+ // We store diagnostics on the `ExpressionOnlySourceMap` because diagnostics are rare (except

+ // maybe for cfgs, and they are also not common in type places).

+ pub(crate) diagnostics: Vec<ExpressionStoreDiagnostics>,

+ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {

+

+ mut expr_map,

+ mut expr_map_back,

+ mut pat_map,

+ mut pat_map_back,

+ mut label_map,

+ mut label_map_back,

+ mut types_map_back,

+ mut types_map,

+ mut lifetime_map_back,

+ mut lifetime_map,

+ mut binding_definitions,

+ mut field_map_back,

+ mut pat_field_map_back,

+ mut template_map,

+ mut expansions,

+ diagnostics,

+ expr_map.shrink_to_fit();

+ expr_map_back.shrink_to_fit();

+ pat_map.shrink_to_fit();

+ pat_map_back.shrink_to_fit();

+ label_map.shrink_to_fit();

+ label_map_back.shrink_to_fit();

+ types_map_back.shrink_to_fit();

+ types_map.shrink_to_fit();

+ lifetime_map_back.shrink_to_fit();

+ lifetime_map.shrink_to_fit();

+ binding_definitions.shrink_to_fit();

+ field_map_back.shrink_to_fit();

+ pat_field_map_back.shrink_to_fit();

+ if let Some(template_map) = &mut template_map {

+ let FormatTemplate {

+ format_args_to_captures,

+ asm_to_captures,

+ implicit_capture_to_source,

+ } = &mut **template_map;

+ format_args_to_captures.shrink_to_fit();

+ asm_to_captures.shrink_to_fit();

+ implicit_capture_to_source.shrink_to_fit();

+ expansions.shrink_to_fit();

+

+ let has_exprs =

+ !exprs.is_empty() || !labels.is_empty() || !pats.is_empty() || !bindings.is_empty();

+

+ let store = {

+ let expr_only = if has_exprs {

+ Some(Box::new(ExpressionOnlyStore {

+ exprs,

+ pats,

+ bindings,

+ labels,

+ binding_owners,

+ block_scopes: block_scopes.into_boxed_slice(),

+ ident_hygiene,

+ }))

+ } else {

+ None

+ };

+ ExpressionStore { expr_only, types, lifetimes }

+ };

+

+ let source_map = {

+ let expr_only = if has_exprs || !expansions.is_empty() || !diagnostics.is_empty() {

+ Some(Box::new(ExpressionOnlySourceMap {

+ expr_map,

+ expr_map_back,

+ pat_map,

+ pat_map_back,

+ label_map,

+ label_map_back,

+ binding_definitions,

+ field_map_back,

+ pat_field_map_back,

+ template_map,

+ expansions,

+ diagnostics: ThinVec::from_iter(diagnostics),

+ }))

+ } else {

+ None

+ };

+ ExpressionStoreSourceMap {

+ expr_only,

+ types_map_back,

+ types_map,

+ lifetime_map_back,

+ lifetime_map,

+ }

+ };

+

+ (store, source_map)

+ pub fn empty_singleton() -> (Arc<ExpressionStore>, Arc<ExpressionStoreSourceMap>) {

+ static EMPTY: LazyLock<(Arc<ExpressionStore>, Arc<ExpressionStoreSourceMap>)> =

+ LazyLock::new(|| {

+ let (store, source_map) = ExpressionStoreBuilder::default().finish();

+ (Arc::new(store), Arc::new(source_map))

+ });

+ self.expr_only

+ .as_ref()

+ .map(|it| &*it.block_scopes)

+ .unwrap_or_default()

+ .iter()

+ .map(move |&block| (block, block_def_map(db, block)))

+ let Some(expr_only) = &self.expr_only else { return false };

+ match expr_only.binding_owners.get(&binding) {

+ #[inline]

+ pub fn binding_owner(&self, id: BindingId) -> Option<ExprId> {

+ self.expr_only.as_ref()?.binding_owners.get(&id).copied()

+ }

+

+ #[inline]

+ #[track_caller]

+ fn assert_expr_only(&self) -> &ExpressionOnlyStore {

+ self.expr_only.as_ref().expect("should have `ExpressionStore::expr_only`")

+ }

+

+ self.assert_expr_only().bindings[binding].hygiene

+ self.assert_expr_only().ident_hygiene.get(&expr.into()).copied().unwrap_or(HygieneId::ROOT)

+ self.assert_expr_only().ident_hygiene.get(&pat.into()).copied().unwrap_or(HygieneId::ROOT)

+

+ #[inline]

+ pub fn exprs(&self) -> impl Iterator<Item = (ExprId, &Expr)> {

+ match &self.expr_only {

+ Some(it) => it.exprs.iter(),

+ None => const { &Arena::new() }.iter(),

+ }

+ }

+

+ #[inline]

+ pub fn pats(&self) -> impl Iterator<Item = (PatId, &Pat)> {

+ match &self.expr_only {

+ Some(it) => it.pats.iter(),

+ None => const { &Arena::new() }.iter(),

+ }

+ }

+

+ #[inline]

+ pub fn bindings(&self) -> impl Iterator<Item = (BindingId, &Binding)> {

+ match &self.expr_only {

+ Some(it) => it.bindings.iter(),

+ None => const { &Arena::new() }.iter(),

+ }

+ }

+ #[inline]

+ &self.assert_expr_only().exprs[expr]

+ #[inline]

+ &self.assert_expr_only().pats[pat]

+ #[inline]

+ &self.assert_expr_only().labels[label]

+ #[inline]

+ &self.assert_expr_only().bindings[b]

+ #[inline]

+ #[inline]

+ #[inline]

+ fn expr_or_synthetic(&self) -> Result<&ExpressionOnlySourceMap, SyntheticSyntax> {

+ self.expr_only.as_deref().ok_or(SyntheticSyntax)

+ }

+

+ #[inline]

+ fn expr_only(&self) -> Option<&ExpressionOnlySourceMap> {

+ self.expr_only.as_deref()

+ }

+

+ #[inline]

+ #[track_caller]

+ fn assert_expr_only(&self) -> &ExpressionOnlySourceMap {

+ self.expr_only.as_ref().expect("should have `ExpressionStoreSourceMap::expr_only`")

+ }

+

+ self.expr_or_synthetic()?.expr_map_back.get(expr).cloned().ok_or(SyntheticSyntax)

+ self.expr_only()?.expr_map.get(&src).cloned()

+ self.expr_only()?.expansions.get(&src).cloned()

+ self.expr_only().into_iter().flat_map(|it| it.expansions.iter().map(|(&a, &b)| (a, b)))

+ self.expr_or_synthetic()?.pat_map_back.get(pat).cloned().ok_or(SyntheticSyntax)

+ self.expr_only()?.pat_map.get(&node.map(AstPtr::new)).cloned()

+ self.assert_expr_only().label_map_back[label]

+ self.assert_expr_only().binding_definitions.get(binding).map_or(&[], Deref::deref)

+ self.expr_only()?.label_map.get(&src).cloned()

+ self.assert_expr_only().field_map_back[&expr]

+ self.assert_expr_only().pat_field_map_back[&pat]

+ self.expr_only()?.expr_map.get(&src).copied()

+ self.expr_only().into_iter().flat_map(|it| it.expansions.iter())

+ self.expr_only()?.expansions.get(&node.map(AstPtr::new)).copied()

+ let expr_only = self.expr_only()?;

+ let (hygiene, names) = expr_only

+ .get(&expr_only.expr_map.get(&src)?.as_expr()?)?;

+ self.expr_only()?

+ .template_map

+ .as_ref()?

+ .implicit_capture_to_source

+ .get(&capture_expr)

+ .copied()

+ let expr_only = self.expr_only()?;

+ let expr = expr_only.expr_map.get(&src)?.as_expr()?;

+ Some(expr).zip(

+ expr_only.template_map.as_ref()?.asm_to_captures.get(&expr).map(std::ops::Deref::deref),

+ )

+ self.expr_only().map(|it| &*it.diagnostics).unwrap_or_default()

+ #[inline]

+ #[inline]

+ let (body, source_map) = lower_body(db, def, file_id, module, params, body, is_async_fn);

+ let (store, source_map) = collector.store.finish();

+ Body { store, params: params.into_boxed_slice(), self_param, body_expr },

+ BodySourceMap { self_param: source_map_self_param, store: source_map },

+ let (store, source_map) = collector.store.finish();

+ Body { store, params: params.into_boxed_slice(), self_param, body_expr },

+ BodySourceMap { self_param: source_map_self_param, store: source_map },

+ let (store, source_map) = expr_collector.store.finish();

+ (store, source_map, type_ref)

+ let (store, source_map) = expr_collector.store.finish();

+ (Arc::new(store), params, source_map)

+ let (store, source_map) = expr_collector.store.finish();

+ (store, source_map, self_ty, trait_, params)

+ let (store, source_map) = expr_collector.store.finish();

+ (store, source_map, params)

+ let (store, source_map) = expr_collector.store.finish();

+ (store, source_map, params)

+ let (store, source_map) = expr_collector.store.finish();

+ (store, source_map, params, bounds, type_ref)

+ let (store, source_map) = expr_collector.store.finish();

+ store,

+ source_map,

+ self.store.types_map.insert(src, id);

+ self.store.types_map_back.insert(id, ptr);

+ self.store.types_map.insert(ptr, id);

+ self.store.lifetime_map_back.insert(id, ptr);

+ self.store.lifetime_map.insert(ptr, id);

+ self.store.diagnostics.push(e);

+ self.store.diagnostics.push(e);

+ self.store.expr_map.insert(src, inner.into());

+ self.store.field_map_back.insert(expr, src);

+ self.store.diagnostics.push(ExpressionStoreDiagnostics::AwaitOutsideOfAsync {

+ node: self.expander.in_file(AstPtr::new(&e)),

+ location: location.to_string(),

+ });

+ self.store.expr_map.insert(src, id.into());

+ self.store.pat_map_back.insert(id, src);

+ self.store.expr_map.insert(src, id.into());

+ self.store.pat_field_map_back.insert(pat, src);

+ this.store.pat_map_back.insert(pat, src);

+ _ = self.store.expansions.insert(ptr.map(|(it, _)| it), call);

+ self.store.diagnostics.push(ExpressionStoreDiagnostics::UnresolvedMacroCall {

+ node: self.expander.in_file(syntax_ptr),

+ path,

+ });

+ self.store

+ self.store.expansions.insert(macro_call_ptr, macro_file);

+ self.store.expr_map.insert(src, tail.into());

+ self.store.pat_field_map_back.insert(pat, src);

+ self.store.pat_map.insert(src, pat.into());

+ self.store.pat_map.insert(src, pat.into());

+ self.store.diagnostics.push(ExpressionStoreDiagnostics::InactiveCode {

+ self.store.binding_definitions.entry(binding_id).or_default().push(pat_id);

+ self.store

+ self.store

+ self.store.expr_map_back.insert(id, src.map(AstPtr::wrap_left));

+ self.store.expr_map.insert(src, id.into());

+ self.store.expr_map_back.insert(id, src.map(AstPtr::wrap_left));

+ // self.store.expr_map.insert(src, id);

+ self.store.expr_map.insert(src, id.into());

+ self.store.pat_map_back.insert(id, src.map(AstPtr::wrap_left));

+ self.store.pat_map.insert(src, id.into());

+ self.store.expr_map_back.insert(id, src.map(AstPtr::wrap_right));

+ self.store.pat_map_back.insert(id, src.map(AstPtr::wrap_right));

+ self.store.pat_map.insert(src, id.into());

+ self.store.label_map_back.insert(id, src);

+ self.store.label_map.insert(src, id);

+ hir::{AsmOperand, AsmOptions, Expr, ExprId, InlineAsm, InlineAsmKind, InlineAsmRegOrRegClass},

+

+ let kind = if asm.global_asm_token().is_some() {

+ InlineAsmKind::GlobalAsm

+ } else if asm.naked_asm_token().is_some() {

+ InlineAsmKind::NakedAsm

+ } else {

+ InlineAsmKind::Asm

+ };

+

+ Expr::InlineAsm(InlineAsm { operands: operands.into_boxed_slice(), options, kind }),

+ self.store

+ let (store, _) = ctx.store.finish();

+ &self.store.assert_expr_only().bindings[*id]

+ let Binding { name, mode, .. } = &self.store.assert_expr_only().bindings[id];

+ scope_by_expr: ArenaMap::with_capacity(

+ body.expr_only.as_ref().map_or(0, |it| it.exprs.len()),

+ ),

+ let Binding { name, .. } = &store[binding];

+ |label: &Option<LabelId>| label.map(|label| (label, store[label].name.clone()));

+ let pat_src =

+ source_map.pat_syntax(source_map.patterns_for_binding(resolved.binding())[0]).unwrap();

+ assert_eq!(body.assert_expr_only().bindings.len(), 1, "should have a binding for `B`");

+ body[BindingId::from_raw(RawIdx::from_u32(0))].name.as_str(),

+ .assert_expr_only()

+ match body[pat] {

+ let hir_start = &body[start.unwrap()];

+ let hir_end = &body[end.unwrap()];

+ pub kind: InlineAsmKind,

+}

+

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

+pub enum InlineAsmKind {

+ /// `asm!()`.

+ Asm,

+ /// `global_asm!()`.

+ GlobalAsm,

+ /// `naked_asm!()`.

+ NakedAsm,

+ // FIXME: Handle `global_asm!()`.

+ ast::Item::AsmExpr(_) => return None,

+ // AstId: ExternCrate[070B, 0]

+ // AstId: ExternCrate[1EA5, 0]

+ // AstId: TypeAlias[A09C, 0]

+ // AstId: Static[D85E, 0]

+ // AstId: Fn[B240, 0]

+ // AstId: Struct[ED35, 0]

+ // AstId: Struct[A47C, 0]

+ // AstId: Struct[C8C9, 0]

+ // AstId: Union[2797, 0]

+ // AstId: Enum[7D23, 0]

+ // AstId: Static[F7C1, 0]

+ // AstId: Const[84BB, 0]

+ // AstId: Fn[BE8F, 0]

+ // AstId: Trait[9320, 0]

+ // AstId: Module[03AE, 0]

+ // AstId: Fn[2A78, 0]

+ // AstId: Module[C08B, 0]

+ // AstId: MacroRules[7E68, 0]

+ // AstId: MacroDef[1C1E, 0]

+ // AstId: MacroCall[7E68, 0], SyntaxContextId: ROOT2024, ExpandTo: Items

+ // AstId: Struct[5024, 0]

+#[rustc_builtin_macro]

+macro_rules! global_asm {() => {}}

+#[rustc_builtin_macro]

+macro_rules! naked_asm {() => {}}

+

+global_asm! {

+ ""

+}

+

+#[unsafe(naked)]

+extern "C" fn foo() {

+ naked_asm!("");

+}

+#[rustc_builtin_macro]

+macro_rules! global_asm {() => {}}

+#[rustc_builtin_macro]

+macro_rules! naked_asm {() => {}}

+

+builtin #global_asm ("")

+

+#[unsafe(naked)]

+extern "C" fn foo() {

+ builtin #naked_asm ("");

+}

+struct#0:MacroRules[BE8F, 0]@58..64#14336# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#14336#

+ map#0:MacroRules[BE8F, 0]@86..89#14336#:#0:MacroRules[BE8F, 0]@89..90#14336# #0:MacroRules[BE8F, 0]@89..90#14336#::#0:MacroRules[BE8F, 0]@91..93#14336#std#0:MacroRules[BE8F, 0]@93..96#14336#::#0:MacroRules[BE8F, 0]@96..98#14336#collections#0:MacroRules[BE8F, 0]@98..109#14336#::#0:MacroRules[BE8F, 0]@109..111#14336#HashSet#0:MacroRules[BE8F, 0]@111..118#14336#<#0:MacroRules[BE8F, 0]@118..119#14336#(#0:MacroRules[BE8F, 0]@119..120#14336#)#0:MacroRules[BE8F, 0]@120..121#14336#>#0:MacroRules[BE8F, 0]@121..122#14336#,#0:MacroRules[BE8F, 0]@122..123#14336#

+}#0:MacroRules[BE8F, 0]@132..133#14336#

+fn#0:MacroCall[BE8F, 0]@30..32#ROOT2024# main#0:MacroCall[BE8F, 0]@33..37#ROOT2024#(#0:MacroCall[BE8F, 0]@37..38#ROOT2024#)#0:MacroCall[BE8F, 0]@38..39#ROOT2024# {#0:MacroCall[BE8F, 0]@40..41#ROOT2024#

+ 1#0:MacroCall[BE8F, 0]@50..51#ROOT2024#;#0:MacroCall[BE8F, 0]@51..52#ROOT2024#

+ 1.0#0:MacroCall[BE8F, 0]@61..64#ROOT2024#;#0:MacroCall[BE8F, 0]@64..65#ROOT2024#

+ (#0:MacroCall[BE8F, 0]@74..75#ROOT2024#(#0:MacroCall[BE8F, 0]@75..76#ROOT2024#1#0:MacroCall[BE8F, 0]@76..77#ROOT2024#,#0:MacroCall[BE8F, 0]@77..78#ROOT2024# )#0:MacroCall[BE8F, 0]@78..79#ROOT2024#,#0:MacroCall[BE8F, 0]@79..80#ROOT2024# )#0:MacroCall[BE8F, 0]@80..81#ROOT2024#.#0:MacroCall[BE8F, 0]@81..82#ROOT2024#0#0:MacroCall[BE8F, 0]@82..85#ROOT2024#.#0:MacroCall[BE8F, 0]@82..85#ROOT2024#0#0:MacroCall[BE8F, 0]@82..85#ROOT2024#;#0:MacroCall[BE8F, 0]@85..86#ROOT2024#

+ let#0:MacroCall[BE8F, 0]@95..98#ROOT2024# x#0:MacroCall[BE8F, 0]@99..100#ROOT2024# =#0:MacroCall[BE8F, 0]@101..102#ROOT2024# 1#0:MacroCall[BE8F, 0]@103..104#ROOT2024#;#0:MacroCall[BE8F, 0]@104..105#ROOT2024#

+}#0:MacroCall[BE8F, 0]@110..111#ROOT2024#

+ /* error: unresolved macro unresolved */"helloworld!"#0:Fn[15AE, 0]@236..321#ROOT2024#;

+struct#1:MacroRules[DB0C, 0]@59..65#14336# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#14336#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#14336#;#1:MacroRules[DB0C, 0]@75..76#14336#

+ builtin::quote::quote,

+use intern::{Symbol, sym};

+use span::{Edition, ROOT_ERASED_FILE_AST_ID, Span, SpanAnchor, SyntaxContext};

+use syntax_bridge::token_tree_to_syntax_node;

+use tt::{TextRange, TextSize};

+

+#[test]

+fn regression_20171() {

+ // This really isn't the appropriate place to put this test, but it's convenient with access to `quote!`.

+ let span = Span {

+ range: TextRange::empty(TextSize::new(0)),

+ anchor: SpanAnchor {

+ file_id: span::EditionedFileId::current_edition(span::FileId::from_raw(0)),

+ ast_id: ROOT_ERASED_FILE_AST_ID,

+ },

+ ctx: SyntaxContext::root(Edition::CURRENT),

+ };

+ let close_brace = tt::Punct { char: '}', spacing: tt::Spacing::Alone, span };

+ let dotdot1 = tt::Punct { char: '.', spacing: tt::Spacing::Joint, span };

+ let dotdot2 = tt::Punct { char: '.', spacing: tt::Spacing::Alone, span };

+ let dollar_crate = sym::dollar_crate;

+ let tt = quote! {

+ span => {

+ if !((matches!(

+ drive_parser(&mut parser, data, false),

+ Err(TarParserError::CorruptField {

+ field: CorruptFieldContext::PaxKvLength,

+ error: GeneralParseError::ParseInt(ParseIntError { #dotdot1 #dotdot2 })

+ })

+ #close_brace ))) {

+ #dollar_crate::panic::panic_2021!();

+ }}

+ };

+ token_tree_to_syntax_node(

+ &tt,

+ syntax_bridge::TopEntryPoint::MacroStmts,

+ &mut |_| Edition::CURRENT,

+ Edition::CURRENT,

+ );

+}

+fn#0:Fn[8A31, 0]@45..47#ROOT2024# foo#0:Fn[8A31, 0]@48..51#ROOT2024#(#0:Fn[8A31, 0]@51..52#ROOT2024#&#0:Fn[8A31, 0]@52..53#ROOT2024#self#0:Fn[8A31, 0]@53..57#ROOT2024# )#0:Fn[8A31, 0]@57..58#ROOT2024# {#0:Fn[8A31, 0]@59..60#ROOT2024#

+ self#0:Fn[8A31, 0]@65..69#ROOT2024# .#0:Fn[8A31, 0]@69..70#ROOT2024#0#0:Fn[8A31, 0]@70..71#ROOT2024#.#0:Fn[8A31, 0]@71..72#ROOT2024#1#0:Fn[8A31, 0]@73..74#ROOT2024#;#0:Fn[8A31, 0]@74..75#ROOT2024#

+}#0:Fn[8A31, 0]@76..77#ROOT2024#"#]],

+#[salsa_macros::tracked]

+pub(crate) struct DefMapPair<'db> {

+ #[tracked]

+ #[returns(ref)]

+ pub(crate) def_map: DefMap,

+ #[returns(ref)]

+ pub(crate) local: LocalDefMap,

+ None => {

+ let (store, source_map) = ExpressionStore::empty_singleton();

+ (Arc::new(VariantFields { fields: Arena::default(), store, shape }), source_map)

+ }

+ col.store.diagnostics.push(

+ let (store, source_map) = col.store.finish();

+ Some((arena, store, source_map))

+ if !matches!(body[body.body_expr], crate::hir::Expr::Missing) {

+ (global_asm, GlobalAsm) => global_asm_expand,

+ (naked_asm, NakedAsm) => naked_asm_expand,

+fn global_asm_expand(

+ _db: &dyn ExpandDatabase,

+ _id: MacroCallId,

+ tt: &tt::TopSubtree,

+ span: Span,

+) -> ExpandResult<tt::TopSubtree> {

+ let mut tt = tt.clone();

+ tt.top_subtree_delimiter_mut().kind = tt::DelimiterKind::Parenthesis;

+ let pound = mk_pound(span);

+ let expanded = quote! {span =>

+ builtin #pound global_asm #tt

+ };

+ ExpandResult::ok(expanded)

+}

+

+fn naked_asm_expand(

+ _db: &dyn ExpandDatabase,

+ _id: MacroCallId,

+ tt: &tt::TopSubtree,

+ span: Span,

+) -> ExpandResult<tt::TopSubtree> {

+ let mut tt = tt.clone();

+ tt.top_subtree_delimiter_mut().kind = tt::DelimiterKind::Parenthesis;

+ let pound = mk_pound(span);

+ let expanded = quote! {span =>

+ builtin #pound naked_asm #tt

+ };

+ ExpandResult::ok(expanded)

+}

+

+pub use quote;

+ db: &dyn crate::db::ExpandDatabase,

+ if matches!(body[body.body_expr], Expr::Missing) {

+ if let Expr::Path(p) = &ctx.body[expr] {

+ // cycle_fn = crate::variance::variances_of_cycle_fn,

+ // cycle_initial = crate::variance::variances_of_cycle_initial,

+ cycle_result = crate::variance::variances_of_cycle_initial,

+ .pats()

+ let bind_name = &body[*id].name;

+ for (id, expr) in body.exprs() {

+ for (id, pat) in body.pats() {

+ match &body[body_expr] {

+ if let Expr::Block { statements, tail, .. } = &self.body[*then_branch] {

+ let name = &self.body[id].name;

+ hir::{AsmOperand, Expr, ExprId, ExprOrPatId, InlineAsmKind, Pat, PatId, Statement, UnaryOp},

+ let pat = &self.body[current];

+ let expr = &self.body[current];

+ match self.body[*expr] {

+ if asm.kind == InlineAsmKind::Asm {

+ // `naked_asm!()` requires `unsafe` on the attribute (`#[unsafe(naked)]`),

+ // and `global_asm!()` doesn't require it at all.

+ self.on_unsafe_op(current.into(), UnsafetyReason::InlineAsm);

+ }

+

+ let expected_len = count * size_one;

+ if bytes.len() < expected_len {

+ never!(

+ "Memory map size is too small. Expected {expected_len}, got {}",

+ bytes.len(),

+ );

+ return f.write_str("<layout-error>");

+ }

+ write!(f, "use<")?;

+ if self.body[b].mode == BindingAnnotation::RefMut {

+ let Binding { mode, .. } = self.body[binding];

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

+use rustc_abi::{AddressSpace, AlignFromBytesError, TargetDataLayoutErrors};

+ .bindings()

+ if provided_lifetimes_count == 0

+ && lifetime_args_len > 0

+ && (!lowering_assoc_type_generics || infer_args)

+ {

+ // In generic associated types, we never allow inferring the lifetimes, but only in type context, that is

+ // when `infer_args == false`. In expression/pattern context we always allow inferring them, even for GATs.

+ MirSpan::BindingId(binding) => {

+ matches!(body[binding].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)

+ }

+ AliasTy, CallableDefId, ClosureId, ComplexMemoryMap, Const, ConstData, ConstScalar, FnDefId,

+ Interner, MemoryMap, Substitution, ToChalk, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,

+ TyKind::Array(inner, len) => {

+ TyKind::Tuple(_, subst) => {

+ TyKind::Adt(adt, subst) => match adt.0 {

+ TyKind::Alias(AliasTy::Projection(proj)) => {

+ let ty = this.db.normalize_projection(proj.clone(), this.trait_env.clone());

+ rec(this, bytes, &ty, locals, mm, stack_depth_limit - 1)?;

+ }

+ if let Expr::Literal(l) = &self.body[expr_id] {

+ match &self.body[expr_id] {

+ match &self.body[*loc] {

+ self.body[id].mode,

+ for (id, _) in self.body.bindings() {

+ .filter(|it| ctx.body.binding_owner(it.0) == Some(expr))

+ let owner = ctx.body.binding_owner(b);

+ match &self.body[expr_id] {

+ Ok(match &self.body[pattern] {

+ Pat::Lit(l) => match &self.body[*l] {

+ Some(b) => LocalName::Binding(self.hir_body[*b].name.clone(), local),

+ if let Pat::Bind { id, .. } = body[pat] {

+ if let Pat::Bind { id, .. } = body[pat] {

+// pub(crate) fn variances_of_cycle_fn(

+// _db: &dyn HirDatabase,

+// _result: &Option<Arc<[Variance]>>,

+// _count: u32,

+// _def: GenericDefId,

+// ) -> salsa::CycleRecoveryAction<Option<Arc<[Variance]>>> {

+// salsa::CycleRecoveryAction::Iterate

+// }

+ FixedPoint[T: bivariant, U: bivariant, V: bivariant]

+ for (binding_id, binding_data) in body.bindings() {

+ /// Is this `asm!()`, or a variant of it (e.g. `global_asm!()`)?

+ pub fn is_asm_like(&self, db: &dyn HirDatabase) -> bool {

+ let starting_expr = body.binding_owner(to_be_renamed.binding_id).unwrap_or(body.body_expr);

+ if mac.is_asm_like(self.db) {

+ if let Pat::Bind { id, .. } = self.store()?[pat_id.as_pat()?] { Some(id) } else { None }

+ let (store, _) = collector.store.finish();

+ let (store, _) = collector.store.finish();

+ let kind = it.kind();

+ !ast::Item::can_cast(kind)

+ || ast::MacroCall::can_cast(kind)

+ || ast::Use::can_cast(kind)

+ || ast::AsmExpr::can_cast(kind)

+ let enum_name = this.db.enum_signature(id).name.as_str().to_smolstr();

+ this.with_container_name(Some(enum_name), |this| {

+ let variants = id.enum_variants(this.db);

+ for (variant_id, variant_name, _) in &variants.variants {

+ this.push_decl(*variant_id, variant_name, true, None);

+ }

+ });

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

+ syntax_editor::SyntaxEditor,

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

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

+ let make = SyntaxFactory::with_mappings();

+ .map(|e| e.syntax().text_range() - pat.syntax().text_range().start())

+ .map(|r| syntax.covering_element(r))

+ editor.replace(

+ make.record_pat_field(

+ make.name_ref(&name_ref.text()),

+ binding.clone_for_update(),

+ .syntax(),

+ editor.replace(extracted_syntax, binding.syntax().clone_for_update());

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

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

+ match_ast,

+ syntax_editor::{Position, SyntaxEditor},

+ let field = ast::make::tuple_field(f.visibility(), f.ty()?);

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

+ editor.insert_all(

+ Position::first_child_of(field.syntax()),

+ let field_syntax = editor.finish().new_root().clone();

+ let field = ast::TupleField::cast(field_syntax)?;

+pub struct Foo(#[my_custom_attr]u32);

+ ast::{self, HasGenericParams, HasName, HasTypeBounds, Impl, make},

+ let ty_or_const_params = generic_params.type_or_const_params().filter_map(|param| {

+ let param = match param {

+ let param = make::type_param(param.name()?, param.type_bound_list());

+ let param = make::const_param(param.name()?, param.ty()?);

+ };

+ Some(param)

+ let assign_stmt = make::expr_stmt(make::expr_assignment(lhs, rhs).into());

+ syntax_editor::{Position, SyntaxEditor},

+fn insert_impl(editor: &mut SyntaxEditor, impl_: &ast::Impl, nominal: &ast::Adt) {

+ editor.insert_all(

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

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

+ let tabstop = edit.make_tabstop_after(cap);

+ editor.add_annotation(l_curly, tabstop);

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

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

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

+ let placeholder = edit.make_placeholder_snippet(cap);

+ editor.add_annotation(trait_.syntax(), placeholder);

+ let tabstop = edit.make_tabstop_after(cap);

+ editor.add_annotation(l_curly, tabstop);

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

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

+use ide_db::{famous_defs::FamousDefs, traits::resolve_target_trait};

+ AstNode, T,

+// &mut self[index as usize]

+ let ast::Type::PathType(path) = impl_def.trait_()? else {

+ return None;

+ };

+ let trait_name = path.path()?.segment()?.name_ref()?;

+

+ let scope = ctx.sema.scope(impl_def.trait_()?.syntax())?;

+ let famous = FamousDefs(&ctx.sema, scope.krate());

+

+ let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;

+ let trait_new = get_trait_mut(&trait_, famous)?;

+ ted::replace(trait_name.syntax(), make::name_ref(trait_new).clone_for_update().syntax());

+ let (trait_method_name, new_trait_method_name) = impl_def

+ .find_map(process_method_name)?;

+ ted::replace(

+ trait_method_name.syntax(),

+ make::name(new_trait_method_name).clone_for_update().syntax(),

+ );

+ if let Some(type_alias) = impl_def.syntax().descendants().find_map(ast::TypeAlias::cast) {

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

+ }

+ let new_ret_type = process_ret_type(&ret_type)?;

+ ted::replace(ret_type.syntax(), make::ret_type(new_ret_type).clone_for_update().syntax());

+ let _ = process_ref_mut(&fn_);

+ format!("Generate `{trait_new}` impl from this `{trait_name}` trait"),

+fn process_ref_mut(fn_: &ast::Fn) -> Option<()> {

+ let expr = fn_.body()?.tail_expr()?;

+ match &expr {

+ ast::Expr::RefExpr(ref_expr) if ref_expr.mut_token().is_none() => {

+ ted::insert_all_raw(

+ ted::Position::after(ref_expr.amp_token()?),

+ vec![make::token(T![mut]).into(), make::tokens::whitespace(" ").into()],

+ );

+ }

+ _ => {}

+ }

+ None

+}

+

+fn get_trait_mut(apply_trait: &hir::Trait, famous: FamousDefs<'_, '_>) -> Option<&'static str> {

+ let trait_ = Some(apply_trait);

+ if trait_ == famous.core_convert_Index().as_ref() {

+ return Some("IndexMut");

+ }

+ if trait_ == famous.core_convert_AsRef().as_ref() {

+ return Some("AsMut");

+ }

+ if trait_ == famous.core_borrow_Borrow().as_ref() {

+ return Some("BorrowMut");

+ }

+ None

+}

+

+fn process_method_name(name: ast::Name) -> Option<(ast::Name, &'static str)> {

+ let new_name = match &*name.text() {

+ "index" => "index_mut",

+ "as_ref" => "as_mut",

+ "borrow" => "borrow_mut",

+ _ => return None,

+ };

+ Some((name, new_name))

+}

+

+fn process_ret_type(ref_ty: &ast::RetType) -> Option<ast::Type> {

+ let ty = ref_ty.ty()?;

+ let ast::Type::RefType(ref_type) = ty else {

+ return None;

+ };

+ Some(make::ty_ref(ref_type.ty()?, true))

+}

+

+ &mut self[index as usize]

+

+ check_assist(

+ generate_mut_trait_impl,

+ r#"

+//- minicore: as_ref

+struct Foo(i32);

+

+impl core::convert::AsRef$0<i32> for Foo {

+ fn as_ref(&self) -> &i32 {

+ &self.0

+ }

+}

+"#,

+ r#"

+struct Foo(i32);

+

+$0impl core::convert::AsMut<i32> for Foo {

+ fn as_mut(&mut self) -> &mut i32 {

+ &mut self.0

+ }

+}

+

+impl core::convert::AsRef<i32> for Foo {

+ fn as_ref(&self) -> &i32 {

+ &self.0

+ }

+}

+"#,

+ );

+ check_assist_not_applicable(

+ generate_mut_trait_impl,

+ r#"

+pub trait AsRef<T: ?Sized> {}

+

+impl AsRef$0<i32> for [T; 3] {}

+"#,

+ );

+ imports::import_assets::item_for_path_search, syntax_helpers::suggest_name::NameGenerator,

+ use_trivial_constructor::use_trivial_constructor,

+ StructKind::Record(named) => {

+ named.fields().filter_map(|f| Some((f.name()?, f.ty()?))).collect::<Vec<_>>()

+ }

+ StructKind::Tuple(tuple) => {

+ let mut name_generator = NameGenerator::default();

+ tuple

+ .fields()

+ .enumerate()

+ .filter_map(|(i, f)| {

+ let ty = f.ty()?;

+ let name = match name_generator.for_type(

+ &ctx.sema.resolve_type(&ty)?,

+ ctx.db(),

+ ctx.edition(),

+ ) {

+ Some(name) => name,

+ None => name_generator.suggest_name(&format!("_{i}")),

+ };

+ Some((make::name(name.as_str()), f.ty()?))

+ })

+ .collect::<Vec<_>>()

+ }

+ StructKind::Unit => return None,

+ .iter()

+ .map(|(name, ty)| {

+ let ty = ctx.sema.resolve_type(ty)?;

+ Some((make::name_ref(&name.text()), Some(expr)))

+ let params = field_list.iter().enumerate().filter_map(|(i, (name, ty))| {

+ Some(make::param(make::ident_pat(false, false, name.clone()).into(), ty.clone()))

+ let fields = field_list.iter().enumerate().map(|(i, (name, _))| {

+ if let Some(constructor) = trivial_constructors[i].clone() {

+ (make::name_ref(&name.text()), None)

+ let tail_expr: ast::Expr = match strukt.kind() {

+ StructKind::Record(_) => {

+ let fields = fields.map(|(name, expr)| make::record_expr_field(name, expr));

+ let fields = make::record_expr_field_list(fields);

+ make::record_expr(make::ext::ident_path("Self"), fields).into()

+ }

+ StructKind::Tuple(_) => {

+ let args = fields.map(|(arg, expr)| {

+ let arg = || make::expr_path(make::path_unqualified(make::path_segment(arg)));

+ expr.unwrap_or_else(arg)

+ });

+ let arg_list = make::arg_list(args);

+ make::expr_call(make::expr_path(make::ext::ident_path("Self")), arg_list).into()

+ }

+ StructKind::Unit => unreachable!(),

+ };

+ let body = make::block_expr(None, tail_expr.into());

+ match strukt.kind() {

+ StructKind::Tuple(_) => {

+ let struct_args = fn_

+ .body()

+ .unwrap()

+ .syntax()

+ .descendants()

+ .filter(|it| syntax::ast::ArgList::can_cast(it.kind()))

+ .flat_map(|args| args.children())

+ .filter(|it| syntax::ast::PathExpr::can_cast(it.kind()))

+ .enumerate()

+ .filter_map(|(i, node)| {

+ if trivial_constructors[i].is_none() { Some(node) } else { None }

+ });

+ if let Some(fn_params) = fn_.param_list() {

+ for (struct_arg, fn_param) in struct_args.zip(fn_params.params()) {

+ if let Some(fn_pat) = fn_param.pat() {

+ let fn_pat = fn_pat.syntax().clone();

+ builder

+ .add_placeholder_snippet_group(cap, vec![struct_arg, fn_pat]);

+ }

+ }

+ }

+ }

+ _ => {}

+ }

+

+ // Add a tabstop before the name

+mod record_tests {

+

+#[cfg(test)]

+mod tuple_tests {

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

+

+ use super::*;

+

+ #[test]

+ fn test_generate_new_with_zst_fields() {

+ check_assist(

+ generate_new,

+ r#"

+struct Empty;

+

+struct Foo(Empty$0);

+"#,

+ r#"

+struct Empty;

+

+struct Foo(Empty);

+

+impl Foo {

+ fn $0new() -> Self {

+ Self(Empty)

+ }

+}

+"#,

+ );

+ check_assist(

+ generate_new,

+ r#"

+struct Empty;

+

+struct Foo(String, Empty$0);

+"#,

+ r#"

+struct Empty;

+

+struct Foo(String, Empty);

+

+impl Foo {

+ fn $0new(${1:_0}: String) -> Self {

+ Self(${1:_0}, Empty)

+ }

+}

+"#,

+ );

+ check_assist(

+ generate_new,

+ r#"

+enum Empty { Bar }

+

+struct Foo(Empty$0);

+"#,

+ r#"

+enum Empty { Bar }

+

+struct Foo(Empty);

+

+impl Foo {

+ fn $0new() -> Self {

+ Self(Empty::Bar)

+ }

+}

+"#,

+ );

+

+ // make sure the assist only works on unit variants

+ check_assist(

+ generate_new,

+ r#"

+struct Empty {}

+

+struct Foo(Empty$0);

+"#,

+ r#"

+struct Empty {}

+

+struct Foo(Empty);

+

+impl Foo {

+ fn $0new(${1:empty}: Empty) -> Self {

+ Self(${1:empty})

+ }

+}

+"#,

+ );

+ check_assist(

+ generate_new,

+ r#"

+enum Empty { Bar {} }

+

+struct Foo(Empty$0);

+"#,

+ r#"

+enum Empty { Bar {} }

+

+struct Foo(Empty);

+

+impl Foo {

+ fn $0new(${1:empty}: Empty) -> Self {

+ Self(${1:empty})

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn test_generate_new() {

+ check_assist(

+ generate_new,

+ r#"

+struct Foo($0);

+"#,

+ r#"

+struct Foo();

+

+impl Foo {

+ fn $0new() -> Self {

+ Self()

+ }

+}

+"#,

+ );

+ check_assist(

+ generate_new,

+ r#"

+struct Foo<T: Clone>($0);

+"#,

+ r#"

+struct Foo<T: Clone>();

+

+impl<T: Clone> Foo<T> {

+ fn $0new() -> Self {

+ Self()

+ }

+}

+"#,

+ );

+ check_assist(

+ generate_new,

+ r#"

+struct Foo<'a, T: Foo<'a>>($0);

+"#,

+ r#"

+struct Foo<'a, T: Foo<'a>>();

+

+impl<'a, T: Foo<'a>> Foo<'a, T> {

+ fn $0new() -> Self {

+ Self()

+ }

+}

+"#,

+ );

+ check_assist(

+ generate_new,

+ r#"

+struct Foo(String$0);

+"#,

+ r#"

+struct Foo(String);

+

+impl Foo {

+ fn $0new(${1:_0}: String) -> Self {

+ Self(${1:_0})

+ }

+}

+"#,

+ );

+ check_assist(

+ generate_new,

+ r#"

+struct Vec<T> { };

+struct Foo(String, Vec<i32>$0);

+"#,

+ r#"

+struct Vec<T> { };

+struct Foo(String, Vec<i32>);

+

+impl Foo {

+ fn $0new(${1:_0}: String, ${2:items}: Vec<i32>) -> Self {

+ Self(${1:_0}, ${2:items})

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn check_that_visibility_modifiers_dont_get_brought_in() {

+ check_assist(

+ generate_new,

+ r#"

+struct Vec<T> { };

+struct Foo(pub String, pub Vec<i32>$0);

+"#,

+ r#"

+struct Vec<T> { };

+struct Foo(pub String, pub Vec<i32>);

+

+impl Foo {

+ fn $0new(${1:_0}: String, ${2:items}: Vec<i32>) -> Self {

+ Self(${1:_0}, ${2:items})

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn generate_new_not_applicable_if_fn_exists() {

+ check_assist_not_applicable(

+ generate_new,

+ r#"

+struct Foo($0);

+

+impl Foo {

+ fn new() -> Self {

+ Self

+ }

+}

+"#,

+ );

+

+ check_assist_not_applicable(

+ generate_new,

+ r#"

+struct Foo($0);

+

+impl Foo {

+ fn New() -> Self {

+ Self

+ }

+}

+"#,

+ );

+ }

+

+ #[test]

+ fn generate_new_target() {

+ check_assist_target(

+ generate_new,

+ r#"

+struct SomeThingIrrelevant;

+/// Has a lifetime parameter

+struct Foo<'a, T: Foo<'a>>($0);

+struct EvenMoreIrrelevant;

+"#,

+ "/// Has a lifetime parameter

+struct Foo<'a, T: Foo<'a>>();",

+ );

+ }

+

+ #[test]

+ fn test_unrelated_new() {

+ check_assist(

+ generate_new,

+ r#"

+pub struct AstId<N: AstNode> {

+ file_id: HirFileId,

+ file_ast_id: FileAstId<N>,

+}

+

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

+ pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {

+ AstId { file_id, file_ast_id }

+ }

+}

+

+pub struct Source<T>(pub HirFileId,$0 pub T);

+

+impl<T> Source<T> {

+ pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {

+ Source(self.file_id, f(self.ast))

+ }

+}

+"#,

+ r#"

+pub struct AstId<N: AstNode> {

+ file_id: HirFileId,

+ file_ast_id: FileAstId<N>,

+}

+

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

+ pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {

+ AstId { file_id, file_ast_id }

+ }

+}

+

+pub struct Source<T>(pub HirFileId, pub T);

+

+impl<T> Source<T> {

+ pub fn $0new(${1:_0}: HirFileId, ${2:_1}: T) -> Self {

+ Self(${1:_0}, ${2:_1})

+ }

+

+ pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {

+ Source(self.file_id, f(self.ast))

+ }

+}

+"#,

+ );

+ }

+}

+use ast::make;

+use hir::{HasCrate, ModuleDef, Semantics};

+use ide_db::{

+ RootDatabase, famous_defs::FamousDefs, helpers::mod_path_to_ast,

+ imports::import_assets::item_for_path_search, use_trivial_constructor::use_trivial_constructor,

+};

+use syntax::{

+ TokenText,

+ ast::{self, AstNode, HasGenericParams, HasName, edit, edit_in_place::Indent},

+};

+

+use crate::{

+ AssistId,

+ assist_context::{AssistContext, Assists},

+ utils::add_cfg_attrs_to,

+};

+

+// Assist: generate_single_field_struct_from

+//

+// Implement From for a single field structure, ignore trivial types.

+//

+// ```

+// # //- minicore: from, phantom_data

+// use core::marker::PhantomData;

+// struct $0Foo<T> {

+// id: i32,

+// _phantom_data: PhantomData<T>,

+// }

+// ```

+// ->

+// ```

+// use core::marker::PhantomData;

+// struct Foo<T> {

+// id: i32,

+// _phantom_data: PhantomData<T>,

+// }

+//

+// impl<T> From<i32> for Foo<T> {

+// fn from(id: i32) -> Self {

+// Self { id, _phantom_data: PhantomData }

+// }

+// }

+// ```

+pub(crate) fn generate_single_field_struct_from(

+ acc: &mut Assists,

+ ctx: &AssistContext<'_>,

+) -> Option<()> {

+ let strukt_name = ctx.find_node_at_offset::<ast::Name>()?;

+ let adt = ast::Adt::cast(strukt_name.syntax().parent()?)?;

+ let ast::Adt::Struct(strukt) = adt else {

+ return None;

+ };

+

+ let sema = &ctx.sema;

+ let (names, types) = get_fields(&strukt)?;

+

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

+ let constructors = make_constructors(ctx, module, &types);

+

+ if constructors.iter().filter(|expr| expr.is_none()).count() != 1 {

+ return None;

+ }

+ let main_field_i = constructors.iter().position(Option::is_none)?;

+ if from_impl_exists(&strukt, main_field_i, &ctx.sema).is_some() {

+ return None;

+ }

+

+ let main_field_name =

+ names.as_ref().map_or(TokenText::borrowed("value"), |names| names[main_field_i].text());

+ let main_field_ty = types[main_field_i].clone();

+

+ acc.add(

+ AssistId::generate("generate_single_field_struct_from"),

+ "Generate single field `From`",

+ strukt.syntax().text_range(),

+ |builder| {

+ let indent = strukt.indent_level();

+ let ty_where_clause = strukt.where_clause();

+ let type_gen_params = strukt.generic_param_list();

+ let type_gen_args = type_gen_params.as_ref().map(|params| params.to_generic_args());

+ let trait_gen_args = Some(make::generic_arg_list([ast::GenericArg::TypeArg(

+ make::type_arg(main_field_ty.clone()),

+ )]));

+

+ let ty = make::ty(&strukt_name.text());

+

+ let constructor =

+ make_adt_constructor(names.as_deref(), constructors, &main_field_name);

+ let body = make::block_expr([], Some(constructor));

+

+ let fn_ = make::fn_(

+ None,

+ make::name("from"),

+ None,

+ None,

+ make::param_list(

+ None,

+ [make::param(

+ make::path_pat(make::path_from_text(&main_field_name)),

+ main_field_ty,

+ )],

+ ),

+ body,

+ Some(make::ret_type(make::ty("Self"))),

+ false,

+ false,

+ false,

+ false,

+ )

+ .clone_for_update();

+

+ fn_.indent(1.into());

+

+ let impl_ = make::impl_trait(

+ false,

+ None,

+ trait_gen_args,

+ type_gen_params,

+ type_gen_args,

+ false,

+ make::ty("From"),

+ ty.clone(),

+ None,

+ ty_where_clause.map(|wc| edit::AstNodeEdit::reset_indent(&wc)),

+ None,

+ )

+ .clone_for_update();

+

+ impl_.get_or_create_assoc_item_list().add_item(fn_.into());

+

+ add_cfg_attrs_to(&strukt, &impl_);

+

+ impl_.reindent_to(indent);

+

+ builder.insert(strukt.syntax().text_range().end(), format!("\n\n{indent}{impl_}"));

+ },

+ )

+}

+

+fn make_adt_constructor(

+ names: Option<&[ast::Name]>,

+ constructors: Vec<Option<ast::Expr>>,

+ main_field_name: &TokenText<'_>,

+) -> ast::Expr {

+ if let Some(names) = names {

+ let fields = make::record_expr_field_list(names.iter().zip(constructors).map(

+ |(name, initializer)| {

+ make::record_expr_field(make::name_ref(&name.text()), initializer)

+ },

+ ));

+ make::record_expr(make::path_from_text("Self"), fields).into()

+ } else {

+ let arg_list = make::arg_list(constructors.into_iter().map(|expr| {

+ expr.unwrap_or_else(|| make::expr_path(make::path_from_text(main_field_name)))

+ }));

+ make::expr_call(make::expr_path(make::path_from_text("Self")), arg_list).into()

+ }

+}

+

+fn make_constructors(

+ ctx: &AssistContext<'_>,

+ module: hir::Module,

+ types: &[ast::Type],

+) -> Vec<Option<ast::Expr>> {

+ let (db, sema) = (ctx.db(), &ctx.sema);

+ types

+ .iter()

+ .map(|ty| {

+ let ty = sema.resolve_type(ty)?;

+ if ty.is_unit() {

+ return Some(make::expr_tuple([]).into());

+ }

+ let item_in_ns = ModuleDef::Adt(ty.as_adt()?).into();

+ let edition = module.krate().edition(db);

+

+ let ty_path = module.find_path(

+ db,

+ item_for_path_search(db, item_in_ns)?,

+ ctx.config.import_path_config(),

+ )?;

+

+ use_trivial_constructor(db, mod_path_to_ast(&ty_path, edition), &ty, edition)

+ })

+ .collect()

+}

+

+fn get_fields(strukt: &ast::Struct) -> Option<(Option<Vec<ast::Name>>, Vec<ast::Type>)> {

+ Some(match strukt.kind() {

+ ast::StructKind::Unit => return None,

+ ast::StructKind::Record(fields) => {

+ let names = fields.fields().map(|field| field.name()).collect::<Option<_>>()?;

+ let types = fields.fields().map(|field| field.ty()).collect::<Option<_>>()?;

+ (Some(names), types)

+ }

+ ast::StructKind::Tuple(fields) => {

+ (None, fields.fields().map(|field| field.ty()).collect::<Option<_>>()?)

+ }

+ })

+}

+

+fn from_impl_exists(

+ strukt: &ast::Struct,

+ main_field_i: usize,

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

+) -> Option<()> {

+ let db = sema.db;

+ let strukt = sema.to_def(strukt)?;

+ let krate = strukt.krate(db);

+ let from_trait = FamousDefs(sema, krate).core_convert_From()?;

+ let ty = strukt.fields(db).get(main_field_i)?.ty(db);

+

+ strukt.ty(db).impls_trait(db, from_trait, &[ty]).then_some(())

+}

+

+#[cfg(test)]

+mod tests {

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

+

+ use super::generate_single_field_struct_from;

+

+ #[test]

+ fn works() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo {

+ foo: i32,

+ }

+ "#,

+ r#"

+ struct Foo {

+ foo: i32,

+ }

+

+ impl From<i32> for Foo {

+ fn from(foo: i32) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from, phantom_data

+ struct $0Foo {

+ b1: (),

+ b2: core::marker::PhantomData,

+ foo: i32,

+ a1: (),

+ a2: core::marker::PhantomData,

+ }

+ "#,

+ r#"

+ struct Foo {

+ b1: (),

+ b2: core::marker::PhantomData,

+ foo: i32,

+ a1: (),

+ a2: core::marker::PhantomData,

+ }

+

+ impl From<i32> for Foo {

+ fn from(foo: i32) -> Self {

+ Self { b1: (), b2: core::marker::PhantomData, foo, a1: (), a2: core::marker::PhantomData }

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn cfgs() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ #[cfg(feature = "foo")]

+ #[cfg(test)]

+ struct $0Foo {

+ foo: i32,

+ }

+ "#,

+ r#"

+ #[cfg(feature = "foo")]

+ #[cfg(test)]

+ struct Foo {

+ foo: i32,

+ }

+

+ #[cfg(feature = "foo")]

+ #[cfg(test)]

+ impl From<i32> for Foo {

+ fn from(foo: i32) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn indent() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ mod foo {

+ struct $0Foo {

+ foo: i32,

+ }

+ }

+ "#,

+ r#"

+ mod foo {

+ struct Foo {

+ foo: i32,

+ }

+

+ impl From<i32> for Foo {

+ fn from(foo: i32) -> Self {

+ Self { foo }

+ }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ mod foo {

+ mod bar {

+ struct $0Foo {

+ foo: i32,

+ }

+ }

+ }

+ "#,

+ r#"

+ mod foo {

+ mod bar {

+ struct Foo {

+ foo: i32,

+ }

+

+ impl From<i32> for Foo {

+ fn from(foo: i32) -> Self {

+ Self { foo }

+ }

+ }

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn where_clause_indent() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ mod foo {

+ mod bar {

+ trait Trait {}

+ struct $0Foo<T>

+ where

+ T: Trait,

+ {

+ foo: T,

+ }

+ }

+ }

+ "#,

+ r#"

+ mod foo {

+ mod bar {

+ trait Trait {}

+ struct Foo<T>

+ where

+ T: Trait,

+ {

+ foo: T,

+ }

+

+ impl<T> From<T> for Foo<T>

+ where

+ T: Trait,

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ mod foo {

+ mod bar {

+ trait Trait<const B: bool> {}

+ struct $0Foo<T>

+ where

+ T: Trait<{

+ true

+ }>

+ {

+ foo: T,

+ }

+ }

+ }

+ "#,

+ r#"

+ mod foo {

+ mod bar {

+ trait Trait<const B: bool> {}

+ struct Foo<T>

+ where

+ T: Trait<{

+ true

+ }>

+ {

+ foo: T,

+ }

+

+ impl<T> From<T> for Foo<T>

+ where

+ T: Trait<{

+ true

+ }>

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn generics() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T> {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T> {

+ foo: T,

+ }

+

+ impl<T> From<T> for Foo<T> {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send> {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send> {

+ foo: T,

+ }

+

+ impl<T: Send> From<T> for Foo<T> {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send> where T: Sync,{

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send> where T: Sync,{

+ foo: T,

+ }

+

+ impl<T: Send> From<T> for Foo<T>

+ where T: Sync,

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send> where T: Sync {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send> where T: Sync {

+ foo: T,

+ }

+

+ impl<T: Send> From<T> for Foo<T>

+ where T: Sync

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send> where T: Sync, Self: Send {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send> where T: Sync, Self: Send {

+ foo: T,

+ }

+

+ impl<T: Send> From<T> for Foo<T>

+ where T: Sync, Self: Send

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send>

+ where T: Sync, Self: Send

+ {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send>

+ where T: Sync, Self: Send

+ {

+ foo: T,

+ }

+

+ impl<T: Send> From<T> for Foo<T>

+ where T: Sync, Self: Send

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send>

+ where T: Sync, Self: Send,

+ {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send>

+ where T: Sync, Self: Send,

+ {

+ foo: T,

+ }

+

+ impl<T: Send> From<T> for Foo<T>

+ where T: Sync, Self: Send,

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send>

+ where T: Sync,

+ Self: Send,

+ {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send>

+ where T: Sync,

+ Self: Send,

+ {

+ foo: T,

+ }

+

+ impl<T: Send> From<T> for Foo<T>

+ where T: Sync,

+ Self: Send,

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send>

+ where

+ T: Sync,

+ Self: Send,

+ {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send>

+ where

+ T: Sync,

+ Self: Send,

+ {

+ foo: T,

+ }

+

+ impl<T: Send> From<T> for Foo<T>

+ where

+ T: Sync,

+ Self: Send,

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T: Send + Sync>

+ where

+ T: Sync,

+ Self: Send,

+ {

+ foo: T,

+ }

+ "#,

+ r#"

+ struct Foo<T: Send + Sync>

+ where

+ T: Sync,

+ Self: Send,

+ {

+ foo: T,

+ }

+

+ impl<T: Send + Sync> From<T> for Foo<T>

+ where

+ T: Sync,

+ Self: Send,

+ {

+ fn from(foo: T) -> Self {

+ Self { foo }

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn tuple() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo(i32);

+ "#,

+ r#"

+ struct Foo(i32);

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self(value)

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T>(T);

+ "#,

+ r#"

+ struct Foo<T>(T);

+

+ impl<T> From<T> for Foo<T> {

+ fn from(value: T) -> Self {

+ Self(value)

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn trivial() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from, phantom_data

+ use core::marker::PhantomData;

+ struct $0Foo(i32, PhantomData<i32>);

+ "#,

+ r#"

+ use core::marker::PhantomData;

+ struct Foo(i32, PhantomData<i32>);

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self(value, PhantomData)

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from, phantom_data

+ use core::marker::PhantomData;

+ struct $0Foo(i32, PhantomData<()>);

+ "#,

+ r#"

+ use core::marker::PhantomData;

+ struct Foo(i32, PhantomData<()>);

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self(value, PhantomData)

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from, phantom_data

+ use core::marker::PhantomData;

+ struct $0Foo(PhantomData<()>, i32, PhantomData<()>);

+ "#,

+ r#"

+ use core::marker::PhantomData;

+ struct Foo(PhantomData<()>, i32, PhantomData<()>);

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self(PhantomData, value, PhantomData)

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from, phantom_data

+ use core::marker::PhantomData;

+ struct $0Foo<T>(PhantomData<T>, i32, PhantomData<()>);

+ "#,

+ r#"

+ use core::marker::PhantomData;

+ struct Foo<T>(PhantomData<T>, i32, PhantomData<()>);

+

+ impl<T> From<i32> for Foo<T> {

+ fn from(value: i32) -> Self {

+ Self(PhantomData, value, PhantomData)

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn unit() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo(i32, ());

+ "#,

+ r#"

+ struct Foo(i32, ());

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self(value, ())

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo((), i32, ());

+ "#,

+ r#"

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

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self((), value, ())

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo((), (), i32, ());

+ "#,

+ r#"

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

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self((), (), value, ())

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn invalid_multiple_main_field() {

+ check_assist_not_applicable(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo(i32, i32);

+ "#,

+ );

+ check_assist_not_applicable(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T>(i32, T);

+ "#,

+ );

+ check_assist_not_applicable(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T>(T, T);

+ "#,

+ );

+ check_assist_not_applicable(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo<T> { foo: T, bar: i32 }

+ "#,

+ );

+ check_assist_not_applicable(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo { foo: i32, bar: i64 }

+ "#,

+ );

+ }

+

+ #[test]

+ fn exists_other_from() {

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo(i32);

+

+ impl From<&i32> for Foo {

+ fn from(value: &i32) -> Self {

+ todo!()

+ }

+ }

+ "#,

+ r#"

+ struct Foo(i32);

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self(value)

+ }

+ }

+

+ impl From<&i32> for Foo {

+ fn from(value: &i32) -> Self {

+ todo!()

+ }

+ }

+ "#,

+ );

+ check_assist(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo(i32);

+

+ type X = i32;

+

+ impl From<&X> for Foo {

+ fn from(value: &X) -> Self {

+ todo!()

+ }

+ }

+ "#,

+ r#"

+ struct Foo(i32);

+

+ impl From<i32> for Foo {

+ fn from(value: i32) -> Self {

+ Self(value)

+ }

+ }

+

+ type X = i32;

+

+ impl From<&X> for Foo {

+ fn from(value: &X) -> Self {

+ todo!()

+ }

+ }

+ "#,

+ );

+ }

+

+ #[test]

+ fn exists_from() {

+ check_assist_not_applicable(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo(i32);

+

+ impl From<i32> for Foo {

+ fn from(_: i32) -> Self {

+ todo!()

+ }

+ }

+ "#,

+ );

+ check_assist_not_applicable(

+ generate_single_field_struct_from,

+ r#"

+ //- minicore: from

+ struct $0Foo(i32);

+

+ type X = i32;

+

+ impl From<X> for Foo {

+ fn from(_: X) -> Self {

+ todo!()

+ }

+ }

+ "#,

+ );

+ }

+}

+ algo::find_node_at_range,

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

+ syntax_editor::SyntaxEditor,

+ let target = tgt.syntax().text_range();

+

+ let edit_tgt = tgt.syntax().clone_subtree();

+ let assignments: Vec<_> = collector

+ .assignments

+ .into_iter()

+ .filter_map(|(stmt, rhs)| {

+ Some((

+ find_node_at_range::<ast::BinExpr>(

+ &edit_tgt,

+ stmt.syntax().text_range() - target.start(),

+ )?,

+ find_node_at_range::<ast::Expr>(

+ &edit_tgt,

+ rhs.syntax().text_range() - target.start(),

+ )?,

+ ))

+ })

+ .collect();

+

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

+ for (stmt, rhs) in assignments {

+ let mut stmt = stmt.syntax().clone();

+ if let Some(parent) = stmt.parent() {

+ if ast::ExprStmt::cast(parent.clone()).is_some() {

+ stmt = parent.clone();

+ }

+ }

+ editor.replace(stmt, rhs.syntax());

+ }

+ let new_tgt_root = editor.finish().new_root().clone();

+ let new_tgt = ast::Expr::cast(new_tgt_root)?;

+ target,

+ let make = SyntaxFactory::with_mappings();

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

+ let assign_expr = make.expr_assignment(collector.common_lhs, new_tgt.clone());

+ let assign_stmt = make.expr_stmt(assign_expr.into());

+

+ editor.replace(tgt.syntax(), assign_stmt.syntax());

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

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

+ Edition, NodeOrToken, SyntaxNode, SyntaxToken, T,

+ ast::{self, AstNode, make},

+ match_ast,

+ syntax_editor::{Position, SyntaxEditor},

+ let target = replacements

+ .iter()

+ .flat_map(|(node_or_token, _)| node_or_token.iter())

+ .map(|t| t.text_range())

+ .reduce(|acc, range| acc.cover(range))?;

+ acc.add(AssistId::quick_fix("remove_dbg"), "Remove dbg!()", target, |builder| {

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

+ for (range, expr) in replacements {

+ if let Some(expr) = expr {

+ editor.insert(Position::before(range[0].clone()), expr.syntax().clone_for_update());

+ }

+ for node_or_token in range {

+ editor.delete(node_or_token);

+ }

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

+ })

+fn compute_dbg_replacement(

+ macro_expr: ast::MacroExpr,

+) -> Option<(Vec<NodeOrToken<SyntaxNode, SyntaxToken>>, Option<ast::Expr>)> {

+ let mut replace = vec![macro_expr.syntax().clone().into()];

+ if let Some(prev_sibling) = macro_expr.syntax().prev_sibling_or_token()

+ && prev_sibling.kind() == syntax::SyntaxKind::WHITESPACE {

+ replace.push(prev_sibling);

+ }

+ (replace, None)

+ let mut replace = vec![it.syntax().clone().into()];

+ if let Some(prev_sibling) = it.syntax().prev_sibling_or_token()

+ && prev_sibling.kind() == syntax::SyntaxKind::WHITESPACE {

+ replace.push(prev_sibling);

+ }

+ (replace, None)

+ _ => (vec![macro_call.syntax().clone().into()], Some(make::ext::expr_unit())),

+ (vec![macro_call.syntax().clone().into()], Some(expr))

+ (vec![macro_call.syntax().clone().into()], Some(expr.into()))

+ let expanded = expanded.clone_subtree();

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

+ editor.replace(mac.syntax(), expr.syntax().clone_for_update());

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

+ let expanded_syntax = editor.finish().new_root().clone();

+ ast::Expr::cast(expanded_syntax).unwrap()

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

+ && let Some(ast::Pat::TupleStructPat(pat)) = let_expr.pat()

+ && let Some(first_var) = pat.fields().next()

+ {

+ let placeholder = edit.make_placeholder_snippet(cap);

+ editor.add_annotation(first_var.syntax(), placeholder);

+ mod generate_single_field_struct_from;

+ generate_single_field_struct_from::generate_single_field_struct_from,

+ &mut self[index as usize]

+fn doctest_generate_single_field_struct_from() {

+ check_doc_test(

+ "generate_single_field_struct_from",

+ r#####"

+//- minicore: from, phantom_data

+use core::marker::PhantomData;

+struct $0Foo<T> {

+ id: i32,

+ _phantom_data: PhantomData<T>,

+}

+"#####,

+ r#####"

+use core::marker::PhantomData;

+struct Foo<T> {

+ id: i32,

+ _phantom_data: PhantomData<T>,

+}

+

+impl<T> From<i32> for Foo<T> {

+ fn from(id: i32) -> Self {

+ Self { id, _phantom_data: PhantomData }

+ }

+}

+"#####,

+ )

+}

+

+#[test]

+ let ty_or_const_params = generic_params.type_or_const_params().filter_map(|param| {

+ let param = match param {

+ let param = make::type_param(param.name()?, make::type_bound_list(bounds));

+ let param = make::const_param(param.name()?, param.ty()?);

+ };

+ Some(param)

+ let ty_or_const_params = generic_params.type_or_const_params().filter_map(|param| {

+ let param = match param {

+ let param = make::type_param(param.name()?, make::type_bound_list(bounds));

+ let param = make::const_param(param.name()?, param.ty()?);

+ };

+ Some(param)

+ add_cfg_attrs_to(adt, &impl_);

+pub(crate) fn add_cfg_attrs_to<T, U>(from: &T, to: &U)

+where

+ T: HasAttrs,

+ U: AttrsOwnerEdit,

+{

+ let cfg_attrs =

+ from.attrs().filter(|attr| attr.as_simple_call().is_some_and(|(name, _arg)| name == "cfg"));

+ for attr in cfg_attrs {

+ to.add_attr(attr.clone_for_update());

+ }

+}

+

+use syntax::ast::HasGenericParams;

+ } else if let Some(end) = transformed_ty

+ .where_clause()

+ .and_then(|wc| wc.where_token())

+ .map(|tok| tok.text_range().start())

+ {

+ end

+ decl.truncate(decl.trim_end().len());

+ decl.push_str(" = ");

+

+ let wc = transformed_ty

+ .where_clause()

+ .map(|wc| {

+ let ws = wc

+ .where_token()

+ .and_then(|it| it.prev_token())

+ .filter(|token| token.kind() == SyntaxKind::WHITESPACE)

+ .map(|token| token.to_string())

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

+ format!("{ws}{wc}")

+ })

+ .unwrap_or_default();

+ let snippet = format!("{decl}$0{wc};");

+ decl.push_str(&wc);

+ #[test]

+ fn includes_where_clause() {

+ check_edit(

+ "type Ty",

+ r#"

+trait Tr {

+ type Ty where Self: Copy;

+}

+

+impl Tr for () {

+ $0

+}

+"#,

+ r#"

+trait Tr {

+ type Ty where Self: Copy;

+}

+

+impl Tr for () {

+ type Ty = $0 where Self: Copy;

+}

+"#,

+ );

+ }

+type O<'a>

+where

+Self: 'a;

+}

+impl B for A {

+$0

+}

+",

+ r#"

+struct A;

+trait B {

+type O<'a>

+where

+Self: 'a;

+}

+impl B for A {

+type O<'a> = $0

+where

+Self: 'a;

+}

+"#,

+ );

+ check_edit(

+ "type O",

+ r"

+struct A;

+trait B {

+ name: "A",

+ def: Variant(

+ Variant {

+ id: EnumVariantId(

+ 7800,

+ ),

+ },

+ ),

+ loc: DeclarationLocation {

+ hir_file_id: FileId(

+ EditionedFileId(

+ Id(2000),

+ ),

+ ),

+ ptr: SyntaxNodePtr {

+ kind: VARIANT,

+ range: 201..202,

+ },

+ name_ptr: AstPtr(

+ SyntaxNodePtr {

+ kind: NAME,

+ range: 201..202,

+ },

+ ),

+ },

+ container_name: Some(

+ "Enum",

+ ),

+ is_alias: false,

+ is_assoc: true,

+ is_import: false,

+ do_not_complete: Yes,

+ },

+ FileSymbol {

+ name: "B",

+ def: Variant(

+ Variant {

+ id: EnumVariantId(

+ 7801,

+ ),

+ },

+ ),

+ loc: DeclarationLocation {

+ hir_file_id: FileId(

+ EditionedFileId(

+ Id(2000),

+ ),

+ ),

+ ptr: SyntaxNodePtr {

+ kind: VARIANT,

+ range: 204..205,

+ },

+ name_ptr: AstPtr(

+ SyntaxNodePtr {

+ kind: NAME,

+ range: 204..205,

+ },

+ ),

+ },

+ container_name: Some(

+ "Enum",

+ ),

+ is_alias: false,

+ is_assoc: true,

+ is_import: false,

+ do_not_complete: Yes,

+ },

+ FileSymbol {

+

+ #[test]

+ fn generic_assoc_type_infer_lifetime_in_expr_position() {

+ check_diagnostics(

+ r#"

+//- minicore: sized

+struct Player;

+

+struct Foo<'c, C> {

+ _v: &'c C,

+}

+trait WithSignals: Sized {

+ type SignalCollection<'c, C>;

+ fn __signals_from_external(&self) -> Self::SignalCollection<'_, Self>;

+}

+impl WithSignals for Player {

+ type SignalCollection<'c, C> = Foo<'c, C>;

+ fn __signals_from_external(&self) -> Self::SignalCollection<'_, Self> {

+ Self::SignalCollection { _v: self }

+ }

+}

+ "#,

+ );

+ }

+

+ #[test]

+ fn naked_asm_is_safe() {

+ check_diagnostics(

+ r#"

+#[rustc_builtin_macro]

+macro_rules! naked_asm { () => {} }

+

+#[unsafe(naked)]

+extern "C" fn naked() {

+ naked_asm!("");

+}

+ "#,

+ );

+ }

+ end_link_type.take().unwrap_or(link_type),

+ if !matches!(end_link_type, Some(LinkType::Autolink)) && link_type.is_some() {

+ if !matches!(end_link_type, Some(LinkType::Autolink)) && link_type.is_some() {

+ Function,

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

+ // for the func with multiline param list

+ if matches!(element.kind(), FN) {

+ if let NodeOrToken::Node(node) = &element {

+ if let Some(fn_node) = ast::Fn::cast(node.clone()) {

+ if !fn_node

+ .param_list()

+ .map(|param_list| param_list.syntax().text().contains_char('\n'))

+ .unwrap_or(false)

+ {

+ continue;

+ }

+

+ if let Some(body) = fn_node.body() {

+ res.push(Fold {

+ range: TextRange::new(

+ node.text_range().start(),

+ node.text_range().end(),

+ ),

+ kind: FoldKind::Function,

+ });

+ merged_fn_bodies.insert(body.syntax().text_range());

+ continue;

+ }

+ }

+ }

+ }

+ FN => Some(FoldKind::Function),

+ #[track_caller]

+ FoldKind::Function => "function",

+ fn test_fold_func_with_multiline_param_list() {

+ check(

+ r#"

+<fold function>fn func<fold arglist>(

+ a: i32,

+ b: i32,

+ c: i32,

+)</fold> <fold block>{

+

+

+

+}</fold></fold>

+"#,

+ );

+ }

+

+ #[test]

+<fold function>fn foo<fold arglist>(

+)</fold> {}</fold>

+

+#[test]

+fn regression_20190() {

+ check(

+ r#"

+struct Foo;

+

+/// [`foo` bar](Foo).

+fn has_docs$0() {}

+ "#,

+ expect![[r#"

+ *has_docs*

+

+ ```rust

+ ra_test_fixture

+ ```

+

+ ```rust

+ fn has_docs()

+ ```

+

+ ---

+

+ [`foo` bar](https://docs.rs/ra_test_fixture/*/ra_test_fixture/struct.Foo.html).

+ "#]],

+ );

+}

+

+#[test]

+fn regression_20225() {

+ check(

+ r#"

+//- minicore: coerce_unsized

+trait Trait {

+ type Type<'a, T: ?Sized + 'a>;

+}

+

+enum Borrowed {}

+

+impl Trait for Borrowed {

+ type Type<'a, T: ?Sized + 'a> = &'a T;

+}

+

+enum Enum<'a, T: Trait + 'a> {

+ Variant1(T::Type<'a, [Enum<'a, T>]>),

+ Variant2,

+}

+

+impl Enum<'_, Borrowed> {

+ const CONSTANT$0: Self = Self::Variant1(&[Self::Variant2]);

+}

+ "#,

+ expect![[r#"

+ *CONSTANT*

+

+ ```rust

+ ra_test_fixture::Enum

+ ```

+

+ ```rust

+ const CONSTANT: Self = Variant1(&[Variant2])

+ ```

+ "#]],

+ );

+}

+ let binding = &hir[binding_idx];

+ let paren = parent

+ .ancestors()

+ .take_while(|it| {

+ ast::ParenType::can_cast(it.kind()) || ast::ForType::can_cast(it.kind())

+ })

+ .last();

+ path.syntax().text_range()

+ // ^ dyn

+ // ^ dyn

+

+ #[test]

+ fn hrtb_bound_does_not_add_dyn() {

+ check(

+ r#"

+//- minicore: fn

+fn test<F>(f: F) where F: for<'a> FnOnce(&'a i32) {}

+ // ^: Sized

+ "#,

+ );

+ }

+

+ #[test]

+ fn with_parentheses() {

+ check(

+ r#"

+trait T {}

+fn foo(v: &(T)) {}

+ // ^ dyn

+ "#,

+ );

+ }

+pub(super) use atom::{EXPR_RECOVERY_SET, LITERAL_FIRST, literal, parse_asm_expr};

+ if p.eat_contextual_kw(T![offset_of]) {

+ } else if p.eat_contextual_kw(T![format_args]) {

+ } else if p.eat_contextual_kw(T![asm])

+ || p.eat_contextual_kw(T![global_asm])

+ || p.eat_contextual_kw(T![naked_asm])

+ {

+ // test asm_kinds

+ // fn foo() {

+ // builtin#asm("");

+ // builtin#global_asm("");

+ // builtin#naked_asm("");

+ // }

+pub(crate) fn parse_asm_expr(p: &mut Parser<'_>, m: Marker) -> Option<CompletedMarker> {

+ // improves error recovery

+ p.error("expected asm operand");

+ } else {

+ p.err_and_bump("expected asm operand");

+ IDENT

+ if p.at_contextual_kw(T![builtin])

+ && p.nth_at(1, T![#])

+ && p.nth_at_contextual_kw(2, T![global_asm]) =>

+ {

+ p.bump_remap(T![builtin]);

+ p.bump(T![#]);

+ p.bump_remap(T![global_asm]);

+ // test global_asm

+ // builtin#global_asm("")

+ expressions::parse_asm_expr(p, m);

+ }

+

+ EscapeError, Mode, unescape_byte, unescape_byte_str, unescape_c_str, unescape_char,

+ unescape_str,

+const PARSER_STEP_LIMIT: usize = if cfg!(debug_assertions) { 150_000 } else { 15_000_000 };

+ let m = self.start();

+ self.error(message);

+ self.bump_any();

+ m.complete(self, ERROR);

+ GLOBAL_ASM_KW,

+ NAKED_ASM_KW,

+ GLOBAL_ASM_KW => "global_asm",

+ NAKED_ASM_KW => "naked_asm",

+ GLOBAL_ASM_KW => true,

+ NAKED_ASM_KW => true,

+ GLOBAL_ASM_KW => true,

+ NAKED_ASM_KW => true,

+ "global_asm" => GLOBAL_ASM_KW,

+ "naked_asm" => NAKED_ASM_KW,

+macro_rules ! T_ { [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: SyntaxKind :: R_CURLY } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; [<] => { $ crate :: SyntaxKind :: L_ANGLE } ; [>] => { $ crate :: SyntaxKind :: R_ANGLE } ; [@] => { $ crate :: SyntaxKind :: AT } ; [#] => { $ crate :: SyntaxKind :: POUND } ; [~] => { $ crate :: SyntaxKind :: TILDE } ; [?] => { $ crate :: SyntaxKind :: QUESTION } ; [&] => { $ crate :: SyntaxKind :: AMP } ; [|] => { $ crate :: SyntaxKind :: PIPE } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [*] => { $ crate :: SyntaxKind :: STAR } ; [/] => { $ crate :: SyntaxKind :: SLASH } ; [^] => { $ crate :: SyntaxKind :: CARET } ; [%] => { $ crate :: SyntaxKind :: PERCENT } ; [_] => { $ crate :: SyntaxKind :: UNDERSCORE } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [..] => { $ crate :: SyntaxKind :: DOT2 } ; [...] => { $ crate :: SyntaxKind :: DOT3 } ; [..=] => { $ crate :: SyntaxKind :: DOT2EQ } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLON2 } ; [=] => { $ crate :: SyntaxKind :: EQ } ; [==] => { $ crate :: SyntaxKind :: EQ2 } ; [=>] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [!] => { $ crate :: SyntaxKind :: BANG } ; [!=] => { $ crate :: SyntaxKind :: NEQ } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [->] => { $ crate :: SyntaxKind :: THIN_ARROW } ; [<=] => { $ crate :: SyntaxKind :: LTEQ } ; [>=] => { $ crate :: SyntaxKind :: GTEQ } ; [+=] => { $ crate :: SyntaxKind :: PLUSEQ } ; [-=] => { $ crate :: SyntaxKind :: MINUSEQ } ; [|=] => { $ crate :: SyntaxKind :: PIPEEQ } ; [&=] => { $ crate :: SyntaxKind :: AMPEQ } ; [^=] => { $ crate :: SyntaxKind :: CARETEQ } ; [/=] => { $ crate :: SyntaxKind :: SLASHEQ } ; [*=] => { $ crate :: SyntaxKind :: STAREQ } ; [%=] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [&&] => { $ crate :: SyntaxKind :: AMP2 } ; [||] => { $ crate :: SyntaxKind :: PIPE2 } ; [<<] => { $ crate :: SyntaxKind :: SHL } ; [>>] => { $ crate :: SyntaxKind :: SHR } ; [<<=] => { $ crate :: SyntaxKind :: SHLEQ } ; [>>=] => { $ crate :: SyntaxKind :: SHREQ } ; [Self] => { $ crate :: SyntaxKind :: SELF_TYPE_KW } ; [abstract] => { $ crate :: SyntaxKind :: ABSTRACT_KW } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [become] => { $ crate :: SyntaxKind :: BECOME_KW } ; [box] => { $ crate :: SyntaxKind :: BOX_KW } ; [break] => { $ crate :: SyntaxKind :: BREAK_KW } ; [const] => { $ crate :: SyntaxKind :: CONST_KW } ; [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [crate] => { $ crate :: SyntaxKind :: CRATE_KW } ; [do] => { $ crate :: SyntaxKind :: DO_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [extern] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [final] => { $ crate :: SyntaxKind :: FINAL_KW } ; [fn] => { $ crate :: SyntaxKind :: FN_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [impl] => { $ crate :: SyntaxKind :: IMPL_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [let] => { $ crate :: SyntaxKind :: LET_KW } ; [loop] => { $ crate :: SyntaxKind :: LOOP_KW } ; [macro] => { $ crate :: SyntaxKind :: MACRO_KW } ; [match] => { $ crate :: SyntaxKind :: MATCH_KW } ; [mod] => { $ crate :: SyntaxKind :: MOD_KW } ; [move] => { $ crate :: SyntaxKind :: MOVE_KW } ; [mut] => { $ crate :: SyntaxKind :: MUT_KW } ; [override] => { $ crate :: SyntaxKind :: OVERRIDE_KW } ; [priv] => { $ crate :: SyntaxKind :: PRIV_KW } ; [pub] => { $ crate :: SyntaxKind :: PUB_KW } ; [ref] => { $ crate :: SyntaxKind :: REF_KW } ; [return] => { $ crate :: SyntaxKind :: RETURN_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [static] => { $ crate :: SyntaxKind :: STATIC_KW } ; [struct] => { $ crate :: SyntaxKind :: STRUCT_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [trait] => { $ crate :: SyntaxKind :: TRAIT_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [typeof] => { $ crate :: SyntaxKind :: TYPEOF_KW } ; [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [unsized] => { $ crate :: SyntaxKind :: UNSIZED_KW } ; [use] => { $ crate :: SyntaxKind :: USE_KW } ; [virtual] => { $ crate :: SyntaxKind :: VIRTUAL_KW } ; [where] => { $ crate :: SyntaxKind :: WHERE_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [yield] => { $ crate :: SyntaxKind :: YIELD_KW } ; [asm] => { $ crate :: SyntaxKind :: ASM_KW } ; [att_syntax] => { $ crate :: SyntaxKind :: ATT_SYNTAX_KW } ; [auto] => { $ crate :: SyntaxKind :: AUTO_KW } ; [builtin] => { $ crate :: SyntaxKind :: BUILTIN_KW } ; [clobber_abi] => { $ crate :: SyntaxKind :: CLOBBER_ABI_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [format_args] => { $ crate :: SyntaxKind :: FORMAT_ARGS_KW } ; [global_asm] => { $ crate :: SyntaxKind :: GLOBAL_ASM_KW } ; [inlateout] => { $ crate :: SyntaxKind :: INLATEOUT_KW } ; [inout] => { $ crate :: SyntaxKind :: INOUT_KW } ; [label] => { $ crate :: SyntaxKind :: LABEL_KW } ; [lateout] => { $ crate :: SyntaxKind :: LATEOUT_KW } ; [macro_rules] => { $ crate :: SyntaxKind :: MACRO_RULES_KW } ; [may_unwind] => { $ crate :: SyntaxKind :: MAY_UNWIND_KW } ; [naked_asm] => { $ crate :: SyntaxKind :: NAKED_ASM_KW } ; [nomem] => { $ crate :: SyntaxKind :: NOMEM_KW } ; [noreturn] => { $ crate :: SyntaxKind :: NORETURN_KW } ; [nostack] => { $ crate :: SyntaxKind :: NOSTACK_KW } ; [offset_of] => { $ crate :: SyntaxKind :: OFFSET_OF_KW } ; [options] => { $ crate :: SyntaxKind :: OPTIONS_KW } ; [out] => { $ crate :: SyntaxKind :: OUT_KW } ; [preserves_flags] => { $ crate :: SyntaxKind :: PRESERVES_FLAGS_KW } ; [pure] => { $ crate :: SyntaxKind :: PURE_KW } ; [raw] => { $ crate :: SyntaxKind :: RAW_KW } ; [readonly] => { $ crate :: SyntaxKind :: READONLY_KW } ; [safe] => { $ crate :: SyntaxKind :: SAFE_KW } ; [sym] => { $ crate :: SyntaxKind :: SYM_KW } ; [union] => { $ crate :: SyntaxKind :: UNION_KW } ; [yeet] => { $ crate :: SyntaxKind :: YEET_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [await] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [gen] => { $ crate :: SyntaxKind :: GEN_KW } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [lifetime_ident] => { $ crate :: SyntaxKind :: LIFETIME_IDENT } ; [int_number] => { $ crate :: SyntaxKind :: INT_NUMBER } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [string] => { $ crate :: SyntaxKind :: STRING } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; [frontmatter] => { $ crate :: SyntaxKind :: FRONTMATTER } ; }

+ fn asm_kinds() { run_and_expect_no_errors("test_data/parser/inline/ok/asm_kinds.rs"); }

+ #[test]

+ fn global_asm() { run_and_expect_no_errors("test_data/parser/inline/ok/global_asm.rs"); }

+ #[test]

+SOURCE_FILE

+ FN

+ FN_KW "fn"

+ WHITESPACE " "

+ NAME

+ IDENT "foo"

+ PARAM_LIST

+ L_PAREN "("

+ R_PAREN ")"

+ WHITESPACE " "

+ BLOCK_EXPR

+ STMT_LIST

+ L_CURLY "{"

+ WHITESPACE "\n "

+ EXPR_STMT

+ ASM_EXPR

+ BUILTIN_KW "builtin"

+ POUND "#"

+ ASM_KW "asm"

+ L_PAREN "("

+ LITERAL

+ STRING "\"\""

+ R_PAREN ")"

+ SEMICOLON ";"

+ WHITESPACE "\n "

+ ASM_EXPR

+ BUILTIN_KW "builtin"

+ POUND "#"

+ GLOBAL_ASM_KW "global_asm"

+ L_PAREN "("

+ LITERAL

+ STRING "\"\""

+ R_PAREN ")"

+ SEMICOLON ";"

+ WHITESPACE "\n "

+ EXPR_STMT

+ ASM_EXPR

+ BUILTIN_KW "builtin"

+ POUND "#"

+ NAKED_ASM_KW "naked_asm"

+ L_PAREN "("

+ LITERAL

+ STRING "\"\""

+ R_PAREN ")"

+ SEMICOLON ";"

+ WHITESPACE "\n"

+ R_CURLY "}"

+ WHITESPACE "\n"

+fn foo() {

+ builtin#asm("");

+ builtin#global_asm("");

+ builtin#naked_asm("");

+}

+SOURCE_FILE

+ ASM_EXPR

+ BUILTIN_KW "builtin"

+ POUND "#"

+ GLOBAL_ASM_KW "global_asm"

+ L_PAREN "("

+ LITERAL

+ STRING "\"\""

+ R_PAREN ")"

+ WHITESPACE "\n"

+builtin#global_asm("")

+//! Read `.cargo/config.toml` as a JSON object

+use rustc_hash::FxHashMap;

+use toolchain::Tool;

+

+use crate::{ManifestPath, Sysroot, utf8_stdout};

+

+pub(crate) type CargoConfigFile = serde_json::Map<String, serde_json::Value>;

+

+pub(crate) fn read(

+ manifest: &ManifestPath,

+ extra_env: &FxHashMap<String, Option<String>>,

+ sysroot: &Sysroot,

+) -> Option<CargoConfigFile> {

+ let mut cargo_config = sysroot.tool(Tool::Cargo, manifest.parent(), extra_env);

+ cargo_config

+ .args(["-Z", "unstable-options", "config", "get", "--format", "json"])

+ .env("RUSTC_BOOTSTRAP", "1");

+ if manifest.is_rust_manifest() {

+ cargo_config.arg("-Zscript");

+ }

+

+ tracing::debug!("Discovering cargo config by {:?}", cargo_config);

+ let json: serde_json::Map<String, serde_json::Value> = utf8_stdout(&mut cargo_config)

+ .inspect(|json| {

+ tracing::debug!("Discovered cargo config: {:?}", json);

+ })

+ .inspect_err(|err| {

+ tracing::debug!("Failed to discover cargo config: {:?}", err);

+ })

+ .ok()

+ .and_then(|stdout| serde_json::from_str(&stdout).ok())?;

+

+ Some(json)

+}

+

+pub(crate) struct FetchMetadata {

+ command: cargo_metadata::MetadataCommand,

+ lockfile_path: Option<Utf8PathBuf>,

+ kind: &'static str,

+ no_deps: bool,

+ no_deps_result: anyhow::Result<cargo_metadata::Metadata>,

+ other_options: Vec<String>,

+}

+

+impl FetchMetadata {

+ /// Builds a command to fetch metadata for the given `cargo_toml` manifest.

+ ///

+ /// Performs a lightweight pre-fetch using the `--no-deps` option,

+ /// available via [`FetchMetadata::no_deps_metadata`], to gather basic

+ /// information such as the `target-dir`.

+ ///

+ /// The provided sysroot is used to set the `RUSTUP_TOOLCHAIN`

+ /// environment variable when invoking Cargo, ensuring that the

+ /// rustup proxy selects the correct toolchain.

+ pub(crate) fn new(

+ cargo_toml: &ManifestPath,

+ current_dir: &AbsPath,

+ config: &CargoMetadataConfig,

+ sysroot: &Sysroot,

+ no_deps: bool,

+ ) -> Self {

+ let cargo = sysroot.tool(Tool::Cargo, current_dir, &config.extra_env);

+ let mut command = MetadataCommand::new();

+ command.cargo_path(cargo.get_program());

+ cargo.get_envs().for_each(|(var, val)| _ = command.env(var, val.unwrap_or_default()));

+ command.manifest_path(cargo_toml.to_path_buf());

+ match &config.features {

+ CargoFeatures::All => {

+ command.features(CargoOpt::AllFeatures);

+ }

+ CargoFeatures::Selected { features, no_default_features } => {

+ if *no_default_features {

+ command.features(CargoOpt::NoDefaultFeatures);

+ }

+ if !features.is_empty() {

+ command.features(CargoOpt::SomeFeatures(features.clone()));

+ }

+ }

+ }

+ command.current_dir(current_dir);

+

+ let mut needs_nightly = false;

+ let mut other_options = vec![];

+ // cargo metadata only supports a subset of flags of what cargo usually accepts, and usually

+ // the only relevant flags for metadata here are unstable ones, so we pass those along

+ // but nothing else

+ let mut extra_args = config.extra_args.iter();

+ while let Some(arg) = extra_args.next() {

+ if arg == "-Z" {

+ if let Some(arg) = extra_args.next() {

+ needs_nightly = true;

+ other_options.push("-Z".to_owned());

+ other_options.push(arg.to_owned());

+ }

+ }

+ }

+

+ let mut lockfile_path = None;

+ if cargo_toml.is_rust_manifest() {

+ needs_nightly = true;

+ other_options.push("-Zscript".to_owned());

+ } else if config

+ .toolchain_version

+ .as_ref()

+ .is_some_and(|v| *v >= MINIMUM_TOOLCHAIN_VERSION_SUPPORTING_LOCKFILE_PATH)

+ {

+ lockfile_path = Some(<_ as AsRef<Utf8Path>>::as_ref(cargo_toml).with_extension("lock"));

+ }

+

+ if !config.targets.is_empty() {

+ other_options.extend(

+ config.targets.iter().flat_map(|it| ["--filter-platform".to_owned(), it.clone()]),

+ );

+ }

+

+ command.other_options(other_options.clone());

+

+ if needs_nightly {

+ command.env("RUSTC_BOOTSTRAP", "1");

+ }

+

+ // Pre-fetch basic metadata using `--no-deps`, which:

+ // - avoids fetching registries like crates.io,

+ // - skips dependency resolution and does not modify lockfiles,

+ // - and thus doesn't require progress reporting or copying lockfiles.

+ //

+ // Useful as a fast fallback to extract info like `target-dir`.

+ let cargo_command;

+ let no_deps_result = if no_deps {

+ command.no_deps();

+ cargo_command = command.cargo_command();

+ command.exec()

+ } else {

+ let mut no_deps_command = command.clone();

+ no_deps_command.no_deps();

+ cargo_command = no_deps_command.cargo_command();

+ no_deps_command.exec()

+ }

+ .with_context(|| format!("Failed to run `{cargo_command:?}`"));

+

+ Self { command, lockfile_path, kind: config.kind, no_deps, no_deps_result, other_options }

+ }

+

+ pub(crate) fn no_deps_metadata(&self) -> Option<&cargo_metadata::Metadata> {

+ self.no_deps_result.as_ref().ok()

+ }

+

+ /// Executes the metadata-fetching command.

+ ///

+ /// A successful result may still contain a metadata error if the full fetch failed,

+ /// but the fallback `--no-deps` pre-fetch succeeded during command construction.

+ pub(crate) fn exec(

+ self,

+ target_dir: &Utf8Path,

+ locked: bool,

+ progress: &dyn Fn(String),

+ ) -> anyhow::Result<(cargo_metadata::Metadata, Option<anyhow::Error>)> {

+ let Self { mut command, lockfile_path, kind, no_deps, no_deps_result, mut other_options } =

+ self;

+

+ if no_deps {

+ return no_deps_result.map(|m| (m, None));

+ }

+

+ let mut using_lockfile_copy = false;

+ // The manifest is a rust file, so this means its a script manifest

+ if let Some(lockfile) = lockfile_path {

+ let target_lockfile =

+ target_dir.join("rust-analyzer").join("metadata").join(kind).join("Cargo.lock");

+ match std::fs::copy(&lockfile, &target_lockfile) {

+ Ok(_) => {

+ using_lockfile_copy = true;

+ other_options.push("--lockfile-path".to_owned());

+ other_options.push(target_lockfile.to_string());

+ }

+ Err(e) if e.kind() == std::io::ErrorKind::NotFound => {

+ // There exists no lockfile yet

+ using_lockfile_copy = true;

+ other_options.push("--lockfile-path".to_owned());

+ other_options.push(target_lockfile.to_string());

+ }

+ Err(e) => {

+ tracing::warn!(

+ "Failed to copy lock file from `{lockfile}` to `{target_lockfile}`: {e}",

+ );

+ }

+ }

+ }

+ if using_lockfile_copy {

+ other_options.push("-Zunstable-options".to_owned());

+ command.env("RUSTC_BOOTSTRAP", "1");

+ }

+ // No need to lock it if we copied the lockfile, we won't modify the original after all/

+ // This way cargo cannot error out on us if the lockfile requires updating.

+ if !using_lockfile_copy && locked {

+ other_options.push("--locked".to_owned());

+ }

+ command.other_options(other_options);

+

+ // FIXME: Fetching metadata is a slow process, as it might require

+ // calling crates.io. We should be reporting progress here, but it's

+ // unclear whether cargo itself supports it.

+ progress("cargo metadata: started".to_owned());

+

+ let res = (|| -> anyhow::Result<(_, _)> {

+ let mut errored = false;

+ let output =

+ spawn_with_streaming_output(command.cargo_command(), &mut |_| (), &mut |line| {

+ errored = errored || line.starts_with("error") || line.starts_with("warning");

+ if errored {

+ progress("cargo metadata: ?".to_owned());

+ return;

+ }

+ progress(format!("cargo metadata: {line}"));

+ })?;

+ if !output.status.success() {

+ progress(format!("cargo metadata: failed {}", output.status));

+ let error = cargo_metadata::Error::CargoMetadata {

+ stderr: String::from_utf8(output.stderr)?,

+ }

+ .into();

+ if !no_deps {

+ // If we failed to fetch metadata with deps, return pre-fetched result without them.

+ // This makes r-a still work partially when offline.

+ if let Ok(metadata) = no_deps_result {

+ tracing::warn!(

+ ?error,

+ "`cargo metadata` failed and returning succeeded result with `--no-deps`"

+ );

+ return Ok((metadata, Some(error)));

+ }

+ }

+ return Err(error);

+ }

+ let stdout = from_utf8(&output.stdout)?

+ .lines()

+ .find(|line| line.starts_with('{'))

+ .ok_or(cargo_metadata::Error::NoJson)?;

+ Ok((cargo_metadata::MetadataCommand::parse(stdout)?, None))

+ })()

+ .with_context(|| format!("Failed to run `{:?}`", command.cargo_command()));

+ progress("cargo metadata: finished".to_owned());

+ res

+ }

+}

+use paths::Utf8Path;