+ // FIXME: This poses an invalidation problem, if one constructs an `EditionedFileId` with a

+ // different crate then whatever the input of a memo used, it will invalidate the memo causing

+ // it to recompute even if the crate is not really used.

+ pub(crate) fn syntax_context(self) -> SyntaxContext {

+/// BlockExpr -> Desugared label from try block

+pub type LabelPtr = AstPtr<Either<ast::Label, ast::BlockExpr>>;

+ let src = node.map(AstPtr::new).map(AstPtr::wrap_left);

+use span::{AstIdMap, SyntaxContext};

+ // FIXME(MINIMUM_SUPPORTED_TOOLCHAIN_VERSION): Remove this once we drop support for <1.86, https://github.com/rust-lang/rust/commit/ac9cb908ac4301dfc25e7a2edee574320022ae2c

+ let label = self.alloc_label_desugared(Label { name: label }, AstPtr::new(&e).wrap_right());

+ hygiene_id.syntax_context().outer_expn(self.db).map(|expansion| {

+ (hygiene_id.syntax_context().parent(self.db), expansion.def)

+ fn alloc_label(&mut self, label: Label, ptr: AstPtr<ast::Label>) -> LabelId {

+ self.alloc_label_desugared(label, ptr.wrap_left())

+ }

+

+ fn alloc_label_desugared(&mut self, label: Label, ptr: LabelPtr) -> LabelId {

+use span::SyntaxContext;

+ let call_ctx = SyntaxContext::root(self.def_map.edition());

+ /// [`None`] only if the type ref is an [`crate::type_ref::TypeRef::ImplTrait`].

+ hir::ExprId,

+ impls: ThinVec<(ImplId, /* trait impl */ bool)>,

+ self.impls.iter().map(|&(id, _)| id)

+ }

+

+ pub fn trait_impls(&self) -> impl Iterator<Item = ImplId> + '_ {

+ self.impls.iter().filter(|&&(_, is_trait_impl)| is_trait_impl).map(|&(id, _)| id)

+ }

+

+ pub fn inherent_impls(&self) -> impl Iterator<Item = ImplId> + '_ {

+ self.impls.iter().filter(|&&(_, is_trait_impl)| !is_trait_impl).map(|&(id, _)| id)

+ pub(crate) fn define_impl(&mut self, imp: ImplId, is_trait_impl: bool) {

+ self.impls.push((imp, is_trait_impl));

+pub struct Impl {

+ pub is_trait_impl: bool,

+}

+ let res = Impl { is_trait_impl: impl_def.trait_().is_some() };

+ let Impl { is_trait_impl: _ } = &self.tree[ast_id];

+ if !crate_def_map.is_unstable_feature_enabled(&sym::lang_items) {

+ return None;

+ }

+

+ for impl_def in module_data.scope.inherent_impls() {

+use base_db::RootQueryDb;

+ _: &dyn ExpandDatabase,

+ self.def_collector.def_map.modules[self.module_id]

+ .scope

+ .define_impl(impl_id, self.item_tree[imp].is_trait_impl)

+ let ctx = hygiene_id.syntax_context();

+ EagerExpander, EditionedFileId, ExpandError, ExpandResult, ExpandTo, FileRange, HirFileId,

+ MacroCallId, MacroCallKind, MacroCallLoc, MacroDefId, MacroDefKind,

+ fn resolve_span(&self, span: Span) -> FileRange;

+

+ #[salsa::transparent]

+fn resolve_span(db: &dyn ExpandDatabase, Span { range, anchor, ctx: _ }: Span) -> FileRange {

+ let file_id = EditionedFileId::from_span_guess_origin(db, anchor.file_id);

+ let anchor_offset =

+ db.ast_id_map(file_id.into()).get_erased(anchor.ast_id).text_range().start();

+ FileRange { file_id, range: range + anchor_offset }

+}

+

+ let range = db.resolve_span(span);

+ InFile { file_id: range.file_id.into(), value: smallvec::smallvec![range.range] }

+ let Span { range, anchor, ctx } = spans.next()?;

+ Some(db.resolve_span(Span { range: TextRange::new(start, end), anchor, ctx }))

+ Some((db.resolve_span(Span { range: TextRange::new(start, end), anchor, ctx }), ctx))

+ (db.resolve_span(span), span.ctx)

+use base_db::{Crate, CrateBuilderId, CratesIdMap, Env, ProcMacroLoadingError};

+ db: &dyn ExpandDatabase,

+ builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},

+ hir::{Expr, ExprId, Literal},

+ StoredConst, StoredGenericArgs, Ty, ValueConst,

+ value: &Literal,

+ _krate: Crate,

+ &Literal::Uint(i, builtin_ty)

+ if builtin_ty.is_none() || ty.as_builtin() == builtin_ty.map(BuiltinType::Uint) =>

+ {

+ let memory = match ty.as_builtin() {

+ Some(BuiltinType::Uint(builtin_uint)) => match builtin_uint {

+ BuiltinUint::U8 => Box::new([i as u8]) as Box<[u8]>,

+ BuiltinUint::U16 => Box::new((i as u16).to_le_bytes()),

+ BuiltinUint::U32 => Box::new((i as u32).to_le_bytes()),

+ BuiltinUint::U64 => Box::new((i as u64).to_le_bytes()),

+ BuiltinUint::U128 => Box::new((i).to_le_bytes()),

+ BuiltinUint::Usize => Box::new((i as usize).to_le_bytes()),

+ },

+ _ => return Const::new(interner, rustc_type_ir::ConstKind::Error(ErrorGuaranteed)),

+ };

+ ConstBytes { memory, memory_map: MemoryMap::default() },

+ ))

+ }

+ &Literal::Int(i, None)

+ if ty

+ .as_builtin()

+ .is_some_and(|builtin_ty| matches!(builtin_ty, BuiltinType::Uint(_))) =>

+ {

+ let memory = match ty.as_builtin() {

+ Some(BuiltinType::Uint(builtin_uint)) => match builtin_uint {

+ BuiltinUint::U8 => Box::new([i as u8]) as Box<[u8]>,

+ BuiltinUint::U16 => Box::new((i as u16).to_le_bytes()),

+ BuiltinUint::U32 => Box::new((i as u32).to_le_bytes()),

+ BuiltinUint::U64 => Box::new((i as u64).to_le_bytes()),

+ BuiltinUint::U128 => Box::new((i as u128).to_le_bytes()),

+ BuiltinUint::Usize => Box::new((i as usize).to_le_bytes()),

+ _ => return Const::new(interner, rustc_type_ir::ConstKind::Error(ErrorGuaranteed)),

+ };

+ rustc_type_ir::ConstKind::Value(ValueConst::new(

+ ty,

+ ConstBytes { memory, memory_map: MemoryMap::default() },

+ &Literal::Int(i, builtin_ty)

+ if builtin_ty.is_none() || ty.as_builtin() == builtin_ty.map(BuiltinType::Int) =>

+ {

+ let memory = match ty.as_builtin() {

+ Some(BuiltinType::Int(builtin_int)) => match builtin_int {

+ BuiltinInt::I8 => Box::new([i as u8]) as Box<[u8]>,

+ BuiltinInt::I16 => Box::new((i as i16).to_le_bytes()),

+ BuiltinInt::I32 => Box::new((i as i32).to_le_bytes()),

+ BuiltinInt::I64 => Box::new((i as i64).to_le_bytes()),

+ BuiltinInt::I128 => Box::new((i).to_le_bytes()),

+ BuiltinInt::Isize => Box::new((i as isize).to_le_bytes()),

+ },

+ _ => return Const::new(interner, rustc_type_ir::ConstKind::Error(ErrorGuaranteed)),

+ };

+ ConstBytes { memory, memory_map: MemoryMap::default() },

+ ))

+ }

+ Literal::Float(float_type_wrapper, builtin_float)

+ if builtin_float.is_none()

+ || ty.as_builtin() == builtin_float.map(BuiltinType::Float) =>

+ {

+ let memory = match ty.as_builtin().unwrap() {

+ BuiltinType::Float(builtin_float) => match builtin_float {

+ // FIXME:

+ hir_def::builtin_type::BuiltinFloat::F16 => Box::new([0u8; 2]) as Box<[u8]>,

+ hir_def::builtin_type::BuiltinFloat::F32 => {

+ Box::new(float_type_wrapper.to_f32().to_le_bytes())

+ }

+ hir_def::builtin_type::BuiltinFloat::F64 => {

+ Box::new(float_type_wrapper.to_f64().to_le_bytes())

+ }

+ // FIXME:

+ hir_def::builtin_type::BuiltinFloat::F128 => Box::new([0; 16]),

+ _ => unreachable!(),

+ };

+ rustc_type_ir::ConstKind::Value(ValueConst::new(

+ ty,

+ ConstBytes { memory, memory_map: MemoryMap::default() },

+ Literal::Bool(b) if ty.is_bool() => rustc_type_ir::ConstKind::Value(ValueConst::new(

+ Literal::Char(c) if ty.is_char() => rustc_type_ir::ConstKind::Value(ValueConst::new(

+ Literal::String(symbol) if ty.is_str() => rustc_type_ir::ConstKind::Value(ValueConst::new(

+ ty,

+ ConstBytes {

+ memory: symbol.as_str().as_bytes().into(),

+ memory_map: MemoryMap::default(),

+ },

+ )),

+ Literal::ByteString(items) if ty.as_slice().is_some_and(|ty| ty.is_u8()) => {

+ rustc_type_ir::ConstKind::Value(ValueConst::new(

+ ty,

+ ConstBytes { memory: items.clone(), memory_map: MemoryMap::default() },

+ ))

+ }

+ // FIXME

+ Literal::CString(_items) => rustc_type_ir::ConstKind::Error(ErrorGuaranteed),

+ _ => rustc_type_ir::ConstKind::Error(ErrorGuaranteed),

+ &match value {

+ Some(value) => Literal::Uint(value, Some(BuiltinUint::Usize)),

+ None => {

+ return Const::new(

+ DbInterner::new_no_crate(db),

+ rustc_type_ir::ConstKind::Error(ErrorGuaranteed),

+ );

+ }

+ },

+#![feature(lang_items)]

+#![feature(lang_items)]

+#![feature(lang_items)]

+ FindPathConfig, GenericDefId, GenericParamId, HasModule, LocalFieldId, Lookup, ModuleDefId,

+ ModuleId, TraitId,

+ fn start_location_link_generic(&mut self, _location: GenericParamId) {}

+ pub fn start_location_link_generic(&mut self, location: GenericParamId) {

+ self.fmt.start_location_link_generic(location);

+ }

+

+ f.start_location_link_generic(param.id.into());

+ f.end_location_link();

+ f.start_location_link_generic(param.id.into());

+ )?;

+ f.end_location_link();

+ f.start_location_link_generic(param.id.into());

+ f.end_location_link();

+ f.start_location_link_generic(param.id.into());

+ f.end_location_link();

+ ConstRef, LifetimeRefId, PathId, TraitBoundModifier, TraitRef as HirTraitRef, TypeBound,

+ TypeRef, TypeRefId,

+ hir_def::hir::Expr::Literal(literal) => {

+ intern_const_ref(self.db, literal, const_type, self.resolver.krate())

+ }

+ &negated_literal,

+ let struct_data = db.struct_signature(def);

+ for impl_id in module_data.scope.inherent_impls() {

+ for impl_id in module_data.scope.trait_impls() {

+ let trait_ref = match db.impl_trait(impl_id) {

+ Some(tr) => tr.instantiate_identity(),

+ None => continue,

+ };

+ #[instrument(level = "debug", skip(self))]

+ pub fn take_opaque_types(

+ &self,

+ ) -> impl IntoIterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> + use<'db> {

+ self.inner.borrow_mut().opaque_type_storage.take_opaque_types()

+ ) -> impl IntoIterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> + use<'db> {

+ #[inline]

+ pub fn is_char(self) -> bool {

+ matches!(self.kind(), TyKind::Char)

+ }

+

+ pub fn is_u8(self) -> bool {

+ matches!(self.kind(), TyKind::Uint(UintTy::U8))

+ }

+

+ #[inline]

+ pub fn as_slice(self) -> Option<Ty<'db>> {

+ match self.kind() {

+ TyKind::Slice(ty) => Some(ty),

+ _ => None,

+ }

+ }

+

+ #[inline]

+ "AttrFlags::query_",

+ "AttrFlags::query_",

+ "AttrFlags::query_",

+ "AttrFlags::query_",

+ "impl_signature_shim",

+ "impl_signature_with_source_map_shim",

+ "AttrFlags::query_",

+ "AttrFlags::query_",

+ "impl_signature_with_source_map_shim",

+ "impl_signature_shim",

+ "AttrFlags::query_",

+ #![feature(lang_items)]

+

+ 108..114 'params': Box<i32, Global>

+ 126..180 '{ ... } }': ()

+ 132..178 'match ... }': ()

+ 138..144 'params': Box<i32, Global>

+ 155..166 'box integer': Box<i32, Global>

+ 159..166 'integer': i32

+ 170..172 '{}': ()

+#![feature(lang_items)]

+#![feature(lang_items)]

+#![feature(lang_items)]

+#![feature(lang_items)]

+#![feature(lang_items)]

+

+ 639..643 'self': Box<[T], A>

+ 672..704 '{ ... }': Vec<T, A>

+ 718..888 '{ ...])); }': ()

+ 728..731 'vec': Vec<i32, Global>

+ 734..749 '<[_]>::into_vec': fn into_vec<i32, Global>(Box<[i32], Global>) -> Vec<i32, Global>

+ 734..780 '<[_]>:...i32]))': Vec<i32, Global>

+ 750..779 '#[rust...1i32])': Box<[i32; 1], Global>

+ 772..778 '[1i32]': [i32; 1]

+ 773..777 '1i32': i32

+ 790..791 'v': Vec<Box<dyn B + 'static, Global>, Global>

+ 811..828 '<[_]> ...to_vec': fn into_vec<Box<dyn B + '?, Global>, Global>(Box<[Box<dyn B + '?, Global>], Global>) -> Vec<Box<dyn B + '?, Global>, Global>

+ 811..885 '<[_]> ...ct)]))': Vec<Box<dyn B + '?, Global>, Global>

+ 829..884 '#[rust...uct)])': Box<[Box<dyn B + '?, Global>; 1], Global>

+ 851..883 '[#[rus...ruct)]': [Box<dyn B + '?, Global>; 1]

+ 852..882 '#[rust...truct)': Box<Astruct, Global>

+ 874..881 'Astruct': Astruct

+#![feature(lang_items)]

+

+ _ => return VariancesOf::empty(DbInterner::new_no_crate(db)).store(),

+ return VariancesOf::empty(DbInterner::new_no_crate(db)).store();

+ let variances =

+ Context { generics, variances: vec![Variance::Bivariant; count].into_boxed_slice(), db }

+ .solve();

+ variances: Box<[Variance]>,

+ fn solve(mut self) -> Box<[Variance]> {

+ src.map(|ast| ast.to_node(&root).left()).transpose()

+ HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalFieldId, Lookup, MacroExpander,

+ MacroId, StaticId, StructId, SyntheticSyntax, TupleId, TypeAliasId, TypeOrConstParamId,

+ TypeParamId, UnionId,

+ {GenericParamId, ModuleDefId, TraitId},

+ let trait_impl = impl_signature.target_trait.is_some();

+ if !trait_impl && !is_inherent_impl_coherent(db, def_map, impl_id) {

+ if trait_impl && !impl_def.check_orphan_rules(db) {

+ let trait_ = trait_impl.then(|| impl_def.trait_(db)).flatten();

+ let trait_is_unresolved = trait_.is_none() && trait_impl;

+ // HACK: When specialization is enabled in the current crate, and there exists

+ // *any* blanket impl that provides a default implementation for the missing item,

+ // suppress the missing associated item diagnostic.

+ // This can lead to false negatives when the impl in question does not actually

+ // specialize that blanket impl, but determining the exact specialization

+ // relationship here would be significantly more expensive.

+ if !missing.is_empty() {

+ let krate = self.krate(db).id;

+ let def_map = crate_def_map(db, krate);

+ if def_map.is_unstable_feature_enabled(&sym::specialization)

+ || def_map.is_unstable_feature_enabled(&sym::min_specialization)

+ {

+ missing.retain(|(assoc_name, assoc_item)| {

+ let AssocItem::Function(_) = assoc_item else {

+ return true;

+ };

+

+ for &impl_ in TraitImpls::for_crate(db, krate).blanket_impls(trait_.id)

+ {

+ if impl_ == impl_id {

+ continue;

+ }

+

+ for (name, item) in &impl_.impl_items(db).items {

+ let AssocItemId::FunctionId(fn_) = item else {

+ continue;

+ };

+ if name != assoc_name {

+ continue;

+ }

+

+ if db.function_signature(*fn_).is_default() {

+ return false;

+ }

+ }

+ }

+

+ true

+ });

+ }

+ }

+

+use itertools::Itertools;

+ ast::{

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

+ syntax_factory::SyntaxFactory,

+ },

+ syntax_editor::Element,

+ |builder| {

+ let make = SyntaxFactory::without_mappings();

+ let mut replace_arms = vec![];

+

+ let expr = match block.tail_expr() {

+ Some(then_expr) if only_expr => then_expr,

+ _ => block.dedent(dedent.into()).into(),

+ };

+ let guard = make.match_guard(cond);

+ let new_arm = make.match_arm(match_pat.clone(), Some(guard), expr);

+ replace_arms.push(new_arm);

+ if let Some(block) = tail {

+ let only_expr = block.statements().next().is_none();

+ let expr = match block.tail_expr() {

+ expr

+ _ => block.dedent(dedent.into()).into(),

+ };

+ let new_arm = make.match_arm(match_pat, None, expr);

+ replace_arms.push(new_arm);

+ _ => {

+ let block_expr = make.expr_empty_block().into();

+ replace_arms.push(make.match_arm(match_pat, None, block_expr));

+ }

+

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

+

+ let newline = make.whitespace(&format!("\n{indent_level}"));

+ let replace_arms = replace_arms.iter().map(|it| it.syntax().syntax_element());

+ let replace_arms = Itertools::intersperse(replace_arms, newline.syntax_element());

+ edit.replace_with_many(match_arm.syntax(), replace_arms.collect());

+

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

+ fn weird_function() (use dep::test_mod::TestTrait) fn() DEPRECATED

+const USELESS_METHOD_PREFIXES: &[&str] = &["try_into_", "into_", "as_", "to_"];

+#![feature(lang_items)]

+

+ #[test]

+ fn no_false_positive_on_specialization() {

+ check_diagnostics(

+ r#"

+#![feature(specialization)]

+

+pub trait Foo {

+ fn foo();

+}

+

+impl<T> Foo for T {

+ default fn foo() {}

+}

+impl Foo for bool {}

+"#,

+ );

+ }

+#![feature(lang_items)]

+ ClosureStyle, DisplayTarget, EditionedFileId, GenericParam, GenericParamId, HasVisibility,

+ HirDisplay, HirDisplayError, HirWrite, InRealFile, ModuleDef, ModuleDefId, Semantics, sym,

+ fn start_location_link_generic(&mut self, def: GenericParamId) {

+ never!(self.location.is_some(), "location link is already started");

+ self.make_new_part();

+

+ self.location = Some(if self.resolve {

+ LazyProperty::Lazy

+ } else {

+ LazyProperty::Computed({

+ let Some(location) = GenericParam::from(def).try_to_nav(self.sema) else { return };

+ let location = location.call_site();

+ FileRange { file_id: location.file_id, range: location.focus_or_full_range() }

+ })

+ });

+ }

+

+ DISABLED_CONFIG, TEST_CONFIG, check, check_edit, check_expect, check_no_edit,

+ check_with_config,

+

+ #[test]

+ fn type_param_inlay_hint_has_location_link() {

+ check_expect(

+ InlayHintsConfig { type_hints: true, ..DISABLED_CONFIG },

+ r#"

+fn identity<T>(t: T) -> T {

+ let x = t;

+ x

+}

+"#,

+ expect![[r#"

+ [

+ (

+ 36..37,

+ [

+ InlayHintLabelPart {

+ text: "T",

+ linked_location: Some(

+ Computed(

+ FileRangeWrapper {

+ file_id: FileId(

+ 0,

+ ),

+ range: 12..13,

+ },

+ ),

+ ),

+ tooltip: "",

+ },

+ ],

+ ),

+ ]

+ "#]],

+ );

+ }

+

+ #[test]

+ fn const_param_inlay_hint_has_location_link() {

+ check_expect(

+ InlayHintsConfig { type_hints: true, ..DISABLED_CONFIG },

+ r#"

+fn f<const N: usize>() {

+ let x = [0; N];

+}

+"#,

+ expect![[r#"

+ [

+ (

+ 33..34,

+ [

+ "[i32; ",

+ InlayHintLabelPart {

+ text: "N",

+ linked_location: Some(

+ Computed(

+ FileRangeWrapper {

+ file_id: FileId(

+ 0,

+ ),

+ range: 11..12,

+ },

+ ),

+ ),

+ tooltip: "",

+ },

+ "]",

+ ],

+ ),

+ ]

+ "#]],

+ );

+ }

+

+ #[test]

+ fn lifetime_param_inlay_hint_has_location_link() {

+ check_expect(

+ InlayHintsConfig { type_hints: true, ..DISABLED_CONFIG },

+ r#"

+struct S<'lt>(*mut &'lt ());

+

+fn f<'a>() {

+ let x = S::<'a>(loop {});

+}

+"#,

+ expect![[r#"

+ [

+ (

+ 51..52,

+ [

+ InlayHintLabelPart {

+ text: "S",

+ linked_location: Some(

+ Computed(

+ FileRangeWrapper {

+ file_id: FileId(

+ 0,

+ ),

+ range: 7..8,

+ },

+ ),

+ ),

+ tooltip: "",

+ },

+ "<",

+ InlayHintLabelPart {

+ text: "'a",

+ linked_location: Some(

+ Computed(

+ FileRangeWrapper {

+ file_id: FileId(

+ 0,

+ ),

+ range: 35..37,

+ },

+ ),

+ ),

+ tooltip: "",

+ },

+ ">",

+ ],

+ ),

+ ]

+ "#]],

+ );

+ }

+ range: 470..475,

+ Analysis, FilePosition, HighlightedRange, NavigationTarget, TryToNav,

+ doc_links::token_as_doc_comment, highlight_related,

+ if let Some(token) = syntax.token_at_offset(offset).left_biased()

+ && let Some(doc_comment) = token_as_doc_comment(&token)

+ {

+ return doc_comment

+ .get_definition_with_descend_at(sema, offset, |def, _, _| Some(vec![def]));

+ }

+

+ fn test_find_all_refs_in_comments() {

+ check(

+ r#"

+struct Foo;

+

+/// $0[`Foo`] is just above

+struct Bar;

+"#,

+ expect![[r#"

+ Foo Struct FileId(0) 0..11 7..10

+

+ (no references)

+ "#]],

+ );

+ }

+

+ #[test]

+ self.map.get_or_init(|| DashMap::with_capacity_and_hasher(1024, Default::default()))

+ self.map.get_or_init(|| {

+ DashMap::with_capacity_and_hasher(

+ (64 * 1024) / std::mem::size_of::<T::SliceType>(),

+ Default::default(),

+ )

+ })

+ lang_items,

+use hir_expand::{

+ db::ExpandDatabase,

+ proc_macro::{

+ ProcMacro, ProcMacroExpander, ProcMacroExpansionError, ProcMacroKind, ProcMacroLoadResult,

+ ProcMacrosBuilder,

+ },

+ base_db::{CrateGraphBuilder, Env, ProcMacroLoadingError, SourceRoot, SourceRootId},

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

+use tt::{TextRange, TextSize};

+ db: &dyn ExpandDatabase,

+ SubRequest::LocalFilePath { file_id } => {

+ let file_id = FileId::from_raw(file_id);

+ let source_root_id = db.file_source_root(file_id).source_root_id(db);

+ let source_root = db.source_root(source_root_id).source_root(db);

+ let name = source_root

+ .path_for_file(&file_id)

+ .and_then(|path| path.as_path())

+ .map(|path| path.to_string());

+

+ Ok(SubResponse::LocalFilePathResult { name })

+ }

+ SubRequest::SourceText { file_id, ast_id, start, end } => {

+ let ast_id = span::ErasedFileAstId::from_raw(ast_id);

+ let editioned_file_id = span::EditionedFileId::from_raw(file_id);

+ let span = Span {

+ range: TextRange::new(TextSize::from(start), TextSize::from(end)),

+ anchor: SpanAnchor { file_id: editioned_file_id, ast_id },

+ ctx: SyntaxContext::root(editioned_file_id.edition()),

+ };

+ let range = db.resolve_span(span);

+ let source = db.file_text(range.file_id.file_id(db)).text(db);

+ let text = source

+ .get(usize::from(range.range.start())..usize::from(range.range.end()))

+ .map(ToOwned::to_owned);

+

+ Ok(SubResponse::SourceTextResult { text })

+ }

+ SubRequest::FilePath { file_id } => {

+ let file_id = FileId::from_raw(file_id);

+ let source_root_id = db.file_source_root(file_id).source_root_id(db);

+ let source_root = db.source_root(source_root_id).source_root(db);

+ let name = source_root

+ .path_for_file(&file_id)

+ .and_then(|path| path.as_path())

+ .map(|path| path.to_string())

+ .unwrap_or_default();

+

+ Ok(SubResponse::FilePathResult { name })

+ FilePath { file_id: u32 },

+ SourceText { file_id: u32, ast_id: u32, start: u32, end: u32 },

+ LocalFilePath { file_id: u32 },

+ FilePathResult { name: String },

+ LocalFilePathResult { name: Option<String> },

+# default = ["sysroot-abi"]

+# proc-macro-srv-cli

+

+A standalone binary for the `proc-macro-srv` crate that provides procedural macro expansion for rust-analyzer.

+

+## Overview

+

+rust-analyzer uses a RPC (via stdio) client-server architecture for procedural macro expansion. This is necessary because:

+

+1. Proc macros are dynamic libraries that can segfault, bringing down the entire process, so running them out of process allows rust-analyzer to recover from fatal errors.

+2. Proc macro dylibs are compiled against a specific rustc version and require matching internal APIs to load and execute, as such having this binary shipped as a rustup component allows us to always match the rustc version irrespective of the rust-analyzer version used.

+

+## The `sysroot-abi` Feature

+

+**The `sysroot-abi` feature is required for the binary to actually function.** Without it, the binary will return an error:

+

+```

+proc-macro-srv-cli needs to be compiled with the `sysroot-abi` feature to function

+```

+

+This feature is necessary because the proc-macro server needs access to unstable rustc internals (`proc_macro_internals`, `proc_macro_diagnostic`, `proc_macro_span`) which are only available on nightly or with `RUSTC_BOOTSTRAP=1`.

+rust-analyzer is a stable toolchain project though, so the feature flag is used to have it remain compilable on stable by default.

+

+### Building

+

+```bash

+# Using nightly toolchain

+cargo build -p proc-macro-srv-cli --features sysroot-abi

+

+# Or with RUSTC_BOOTSTRAP on stable

+RUSTC_BOOTSTRAP=1 cargo build -p proc-macro-srv-cli --features sysroot-abi

+```

+

+### Installing the proc-macro server

+

+For local testing purposes, you can install the proc-macro server using the xtask command:

+

+```bash

+# Recommended: use the xtask command

+cargo xtask install --proc-macro-server

+```

+

+## Testing

+

+```bash

+cargo test --features sysroot-abi -p proc-macro-srv -p proc-macro-srv-cli -p proc-macro-api

+```

+

+The tests use a test proc macro dylib built by the `proc-macro-test` crate, which compiles a small proc macro implementation during build time.

+

+**Note**: Tests only compile on nightly toolchains (or with `RUSTC_BOOTSTRAP=1`).

+

+## Usage

+

+The binary requires the `RUST_ANALYZER_INTERNALS_DO_NOT_USE` environment variable to be set. This is intentional—the binary is an implementation detail of rust-analyzer and its API is still unstable:

+

+```bash

+RUST_ANALYZER_INTERNALS_DO_NOT_USE=1 rust-analyzer-proc-macro-srv --version

+```

+

+## Related Crates

+

+- `proc-macro-srv`: The core server library that handles loading dylibs and expanding macros, but not the RPC protocol.

+- `proc-macro-api`: The client library used by rust-analyzer to communicate with this server as well as the protocol definitions.

+- `proc-macro-test`: Test harness with sample proc macros for testing

+- `proc-macro-srv-cli`: The actual server binary that handles the RPC protocol.

+impl<'a, C: Codec> ProcMacroClientHandle<'a, C> {

+ fn roundtrip(

+ &mut self,

+ req: bidirectional::SubRequest,

+ ) -> Option<bidirectional::BidirectionalMessage> {

+ let msg = bidirectional::BidirectionalMessage::SubRequest(req);

+ if msg.write::<_, C>(&mut self.stdout.lock()).is_err() {

+ match bidirectional::BidirectionalMessage::read::<_, C>(&mut self.stdin.lock(), self.buf) {

+ Ok(Some(msg)) => Some(msg),

+ _ => None,

+ }

+ }

+}

+

+impl<C: Codec> proc_macro_srv::ProcMacroClientInterface for ProcMacroClientHandle<'_, C> {

+ fn file(&mut self, file_id: proc_macro_srv::span::FileId) -> String {

+ match self.roundtrip(bidirectional::SubRequest::FilePath { file_id: file_id.index() }) {

+ Some(bidirectional::BidirectionalMessage::SubResponse(

+ bidirectional::SubResponse::FilePathResult { name },

+ )) => name,

+ _ => String::new(),

+ }

+ }

+ fn source_text(

+ &mut self,

+ proc_macro_srv::span::Span { range, anchor, ctx: _ }: proc_macro_srv::span::Span,

+ ) -> Option<String> {

+ match self.roundtrip(bidirectional::SubRequest::SourceText {

+ file_id: anchor.file_id.as_u32(),

+ ast_id: anchor.ast_id.into_raw(),

+ start: range.start().into(),

+ end: range.end().into(),

+ }) {

+ Some(bidirectional::BidirectionalMessage::SubResponse(

+ )) => text,

+ _ => None,

+ }

+ }

+

+ fn local_file(&mut self, file_id: proc_macro_srv::span::FileId) -> Option<String> {

+ match self.roundtrip(bidirectional::SubRequest::LocalFilePath { file_id: file_id.index() })

+ {

+ Some(bidirectional::BidirectionalMessage::SubResponse(

+ bidirectional::SubResponse::LocalFilePathResult { name },

+ )) => name,

+pub use span;

+ fn file(&mut self, file_id: span::FileId) -> String;

+ fn source_text(&mut self, span: Span) -> Option<String>;

+ fn local_file(&mut self, file_id: span::FileId) -> Option<String>;

+ fn file(&mut self, span: Self::Span) -> String {

+ self.callback.as_mut().map(|cb| cb.file(span.anchor.file_id.file_id())).unwrap_or_default()

+ fn local_file(&mut self, span: Self::Span) -> Option<String> {

+ self.callback.as_mut().and_then(|cb| cb.local_file(span.anchor.file_id.file_id()))

+ self.callback.as_mut()?.source_text(span)

+/*

+ If you bump this, grep for `FIXME(MINIMUM_SUPPORTED_TOOLCHAIN_VERSION)` to check for old support code we can drop

+*/

+use std::fmt;

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+ _: &dyn ExpandDatabase,

+#![feature(lang_items)]

+ "version": "6.14.1",

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

+ "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==",