+version = "2.7.0"

+checksum = "1be3f42a67d6d345ecd59f675f3f012d6974981560836e938c22b424b85ce1be"

+version = "0.99.0"

+checksum = "572583d9b97f9d277e5c7607f8239a30e2e04d3ed3b47c87d1cb2152ae724073"

+version = "0.99.0"

+checksum = "e60e0ef9c81dce1336a9ed3c76f08775f5b623151d96d85ba45f7b10de76d1c7"

+ "bitflags 2.7.0",

+version = "0.99.0"

+checksum = "5a06350d614e22b03a69b8105e3541614450a7ea48bc58ecc6c6bd92731a3995"

+version = "0.99.0"

+checksum = "0e428761e9b55bee516bfe2457caed8b6d1b86353f92ae825bbe438a36ce91e8"

+ "indexmap",

+ "bitflags 2.7.0",

+ "bitflags 2.7.0",

+ "bitflags 2.7.0",

+version = "0.11.0"

+checksum = "f37dccff2791ab604f9babef0ba14fbe0be30bd368dc541e2b08d07c8aa908f3"

+ "bitflags 2.7.0",

+version = "0.2.169"

+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"

+ "bitflags 2.7.0",

+version = "1.0.3"

+checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"

+ "windows-sys 0.52.0",

+ "bitflags 2.7.0",

+version = "8.0.0"

+checksum = "2fee8403b3d66ac7b26aee6e40a897d85dc5ce26f44da36b8b73e987cc52e943"

+ "bitflags 2.7.0",

+ "notify-types",

+ "windows-sys 0.59.0",

+name = "notify-types"

+version = "2.0.0"

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

+checksum = "5e0826a989adedc2a244799e823aece04662b66609d96af8dff7ac6df9a8925d"

+

+[[package]]

+ "libc",

+ "windows-sys 0.59.0",

+ "bitflags 2.7.0",

+version = "0.91.0"

+checksum = "d5246e9e1f450333a990877eabbc36fe0567e7cedd56d5365db319e14079cf2a"

+ "bitflags 2.7.0",

+version = "0.91.0"

+checksum = "59fd8e4f5b34c434ec111efb0e0614954db048b9307d3b2e4cc3c915da9d2160"

+version = "0.91.0"

+checksum = "2d34973fe081392bd1edb022e865e9952fcaa093f9cdae183edce64472e5e889"

+version = "0.91.0"

+checksum = "52fa42c582e21b35e8f61a5afe3c63a9c722d995826762eb19b18beeccf5157f"

+version = "0.91.0"

+checksum = "740383328d7033393e5385f4a6073b880d5811b0fc0fd2559e481f905940f2f8"

+version = "0.91.0"

+checksum = "c39f544728f32cebffb1a8b92ba3c1f3dcb4144081438d192137ed197d479a9d"

+ "bitflags 2.7.0",

+ "windows-sys 0.59.0",

+ "windows-sys 0.59.0",

+rust-version = "1.83"

+test-fixture = { path = "./crates/test-fixture", version = "0.0.0" }

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

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

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

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

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

+# in-tree crates that are published separately and follow semver. See lib/README.md

+chalk-solve = { version = "0.99.0", default-features = false }

+chalk-ir = "0.99.0"

+chalk-recursive = { version = "0.99.0", default-features = false }

+chalk-derive = "0.99.0"

+ /// Crates whose root file is in `id`.

+ // The syntax context stuff needs the discriminants to start from 0 and be consecutive.

+ Edition2015 = 0,

+ pub fn rust_analyzer_tool(&self) -> impl Iterator<Item = &Attr> {

+ self.iter()

+ .filter(|&attr| attr.path.segments().first().is_some_and(|s| *s == sym::rust_analyzer))

+ }

+

+use span::{Edition, MacroFileId, SyntaxContextData};

+pub struct HygieneId(span::SyntaxContextId);

+ // The edition doesn't matter here, we only use this for comparisons and to lookup the macro.

+ pub const ROOT: Self = Self(span::SyntaxContextId::root(Edition::Edition2015));

+ pub fn new(mut ctx: span::SyntaxContextId) -> Self {

+ // See `Name` for why we're doing that.

+ ctx.remove_root_edition();

+ pub(crate) fn lookup(self, db: &dyn DefDatabase) -> SyntaxContextData {

+ db.lookup_intern_syntax_context(self.0)

+ }

+

+ mod_path::tool_path,

+ attr::Attrs,

+ let skip_body = match self.owner {

+ DefWithBodyId::FunctionId(it) => self.db.attrs(it.into()),

+ DefWithBodyId::StaticId(it) => self.db.attrs(it.into()),

+ DefWithBodyId::ConstId(it) => self.db.attrs(it.into()),

+ DefWithBodyId::InTypeConstId(_) => Attrs::EMPTY,

+ DefWithBodyId::VariantId(it) => self.db.attrs(it.into()),

+ }

+ .rust_analyzer_tool()

+ .any(|attr| *attr.path() == tool_path![skip]);

+ // If #[rust_analyzer::skip] annotated, only construct enough information for the signature

+ // and skip the body.

+ if skip_body {

+ self.body.body_expr = self.missing_expr();

+ if let Some((param_list, mut attr_enabled)) = param_list {

+ if let Some(self_param) =

+ param_list.self_param().filter(|_| attr_enabled.next().unwrap_or(false))

+ {

+ let is_mutable =

+ self_param.mut_token().is_some() && self_param.amp_token().is_none();

+ let binding_id: la_arena::Idx<Binding> = self.alloc_binding(

+ Name::new_symbol_root(sym::self_.clone()),

+ BindingAnnotation::new(is_mutable, false),

+ );

+ self.body.self_param = Some(binding_id);

+ self.source_map.self_param =

+ Some(self.expander.in_file(AstPtr::new(&self_param)));

+ }

+ self.body.params = param_list

+ .params()

+ .zip(attr_enabled)

+ .filter(|(_, enabled)| *enabled)

+ .map(|_| self.missing_pat())

+ .collect();

+ };

+ return (self.body, self.source_map);

+ }

+

+ HygieneId::new(self.db.lookup_intern_syntax_context(ctx).opaque_and_semitransparent)

+ fn do_check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected: &[&str]) {

+ fn do_check_local_name(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected_offset: u32) {

+fn lower(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> (TestDB, Arc<Body>, DefWithBodyId) {

+fn def_map_at(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> String {

+fn check_block_scopes_at(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+fn check_at(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+

+#[test]

+fn skip_skips_body() {

+ let (db, body, owner) = lower(

+ r#"

+#[rust_analyzer::skip]

+async fn foo(a: (), b: i32) -> u32 {

+ 0 + 1 + b()

+}

+"#,

+ );

+ let printed = body.pretty_print(&db, owner, Edition::CURRENT);

+ expect!["fn foo(�: (), �: i32) -> impl ::core::future::Future::<Output = u32> �"]

+ .assert_eq(&printed);

+}

+ pub items: Box<[(Name, AssocItemId)]>,

+ pub items: Box<[(Name, AssocItemId)]>,

+ Box<[(Name, AssocItemId)]>,

+ self.items.into_boxed_slice(),

+use span::{Edition, SyntaxContextId};

+ SyntaxContextId::root(Edition::CURRENT)

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ fn check_found_path(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ path: &str,

+ expect: Expect,

+ ) {

+ fn check_found_path_prelude(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ path: &str,

+ expect: Expect,

+ ) {

+ fn check_found_path_absolute(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ path: &str,

+ expect: Expect,

+ ) {

+ fn check_found_path_prefer_no_std(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ path: &str,

+ expect: Expect,

+ ) {

+ fn check_search(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ crate_name: &str,

+ query: Query,

+ expect: Expect,

+ ) {

+ fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+ pub fn values(&self) -> impl Iterator<Item = (&Name, Item<ModuleDefId, ImportId>)> + '_ {

+ self.values.iter().map(|(n, &i)| (n, i))

+ }

+

+ pub fn types(

+ &self,

+ ) -> impl Iterator<Item = (&Name, Item<ModuleDefId, ImportOrExternCrate>)> + '_ {

+ self.types.iter().map(|(n, &i)| (n, i))

+ }

+

+ pub fn macros(&self) -> impl Iterator<Item = (&Name, Item<MacroId, ImportId>)> + '_ {

+ self.macros.iter().map(|(n, &i)| (n, i))

+ }

+

+fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+ // AstId: 3, SyntaxContext: 2, ExpandTo: Items

+ for &(_, assoc) in db.impl_data(impl_def).items.iter() {

+ pub fn is_crate_root(&self) -> bool {

+struct#0:[email protected]#4# MyTraitMap2#0:[email protected]#2# {#0:[email protected]#4#

+ map#0:[email protected]#4#:#0:[email protected]#4# #0:[email protected]#4#::#0:[email protected]#4#std#0:[email protected]#4#::#0:[email protected]#4#collections#0:[email protected]#4#::#0:[email protected]#4#HashSet#0:[email protected]#4#<#0:[email protected]#4#(#0:[email protected]#4#)#0:[email protected]#4#>#0:[email protected]#4#,#0:[email protected]#4#

+}#0:[email protected]#4#

+fn#0:[email protected]#2# main#0:[email protected]#2#(#0:[email protected]#2#)#0:[email protected]#2# {#0:[email protected]#2#

+ 1#0:[email protected]#2#;#0:[email protected]#2#

+ 1.0#0:[email protected]#2#;#0:[email protected]#2#

+ (#0:[email protected]#2#(#0:[email protected]#2#1#0:[email protected]#2#,#0:[email protected]#2# )#0:[email protected]#2#,#0:[email protected]#2# )#0:[email protected]#2#.#0:[email protected]#2#0#0:[email protected]#2#.#0:[email protected]#2#0#0:[email protected]#2#;#0:[email protected]#2#

+ let#0:[email protected]#2# x#0:[email protected]#2# =#0:[email protected]#2# 1#0:[email protected]#2#;#0:[email protected]#2#

+}#0:[email protected]#2#

+ /* error: unresolved macro unresolved */"helloworld!"#0:[email protected]#2#;

+struct#1:[email protected]#4# Foo#0:[email protected]#2#(#1:[email protected]#4#u32#0:[email protected]#2#)#1:[email protected]#4#;#1:[email protected]#4#

+impl#\4# Bar#\4# {#\4#

+ fn#\4# foo#\2#(#\4#)#\4# {#\4#}#\4#

+ fn#\4# bar#\2#(#\4#)#\4# {#\4#}#\4#

+}#\4#

+fn check_errors(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, mut expect: Expect) {

+ &mut |_| span::Edition::CURRENT,

+fn#0:[email protected]#2# foo#0:[email protected]#2#(#0:[email protected]#2#&#0:[email protected]#2#self#0:[email protected]#2# )#0:[email protected]#2# {#0:[email protected]#2#

+ self#0:[email protected]#2# .#0:[email protected]#2#0#0:[email protected]#2#.#0:[email protected]#2#1#0:[email protected]#2#;#0:[email protected]#2#

+}#0:[email protected]#2#"#]],

+ .for_crate(def_map.krate, db.syntax_context(tree_id.file_id(), krate.edition))

+ for (name, it) in root_scope.macros() {

+ self.def_map.macro_use_prelude.insert(name.clone(), (it.def, extern_crate));

+fn compute_crate_def_map(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> Arc<DefMap> {

+fn render_crate_def_map(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> String {

+fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+ self.resolve_path_in_type_ns_with_prefix_info(db, path).map(

+ |(resolution, remaining_segments, import, _)| (resolution, remaining_segments, import),

+ )

+ }

+

+ pub fn resolve_path_in_type_ns_with_prefix_info(

+ &self,

+ db: &dyn DefDatabase,

+ path: &Path,

+ ) -> Option<(TypeNs, Option<usize>, Option<ImportOrExternCrate>, ResolvePathResultPrefixInfo)>

+ {

+ return Some((

+ type_ns,

+ seg.as_ref().map(|_| 1),

+ None,

+ ResolvePathResultPrefixInfo::default(),

+ ));

+ return Some((

+ TypeNs::GenericParam(id),

+ remaining_idx(),

+ None,

+ ResolvePathResultPrefixInfo::default(),

+ ));

+ return Some((

+ TypeNs::SelfType(impl_),

+ remaining_idx(),

+ None,

+ ResolvePathResultPrefixInfo::default(),

+ ));

+ return Some((

+ TypeNs::AdtSelfType(adt),

+ remaining_idx(),

+ None,

+ ResolvePathResultPrefixInfo::default(),

+ ));

+ let ctx = hygiene_id.lookup(db);

+ ) -> Option<(TypeNs, Option<usize>, Option<ImportOrExternCrate>, ResolvePathResultPrefixInfo)>

+ {

+ let (module_def, idx, prefix_info) =

+ Some((res, idx, import, prefix_info))

+ return Some(Visibility::Module(mod_a, expl_a));

+ return Some(Visibility::Module(mod_b, expl_b));

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

+ pub fn expander(&self) -> fn(&dyn ExpandDatabase, Span, &tt::TopSubtree) -> ExpandResult<tt::TopSubtree> {

+ let span = span_with_def_site_ctxt(db, span, id, Edition::CURRENT);

+ self.expander()(db, span, tt)

+fn parse_adt(

+ db: &dyn ExpandDatabase,

+ tt: &tt::TopSubtree,

+ call_site: Span,

+) -> Result<BasicAdtInfo, ExpandError> {

+ let (adt, tm) = to_adt_syntax(db, tt, call_site)?;

+ db: &dyn ExpandDatabase,

+ let (parsed, tm) = crate::db::token_tree_to_syntax_node(

+ db,

+ crate::ExpandTo::Items,

+ db: &dyn ExpandDatabase,

+ let info = match parse_adt(db, tt, invoc_span) {

+fn copy_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::marker::Copy }, |_| quote! {span =>})

+fn clone_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::clone::Clone }, |adt| {

+fn default_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::default::Default }, |adt| {

+fn debug_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::fmt::Debug }, |adt| {

+fn hash_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::hash::Hash }, |adt| {

+fn eq_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::cmp::Eq }, |_| quote! {span =>})

+fn partial_eq_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::cmp::PartialEq }, |adt| {

+fn ord_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::cmp::Ord }, |adt| {

+fn partial_ord_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ expand_simple_derive(db, span, tt, quote! {span => #krate::cmp::PartialOrd }, |adt| {

+fn coerce_pointee_expand(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ tt: &tt::TopSubtree,

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

+ let (adt, _span_map) = match to_adt_syntax(db, tt, span) {

+ let span = span_with_def_site_ctxt(db, span, id, Edition::CURRENT);

+ let span = span_with_def_site_ctxt(db, span, id, Edition::CURRENT);

+ let call_site_span = span_with_call_site_ctxt(db, span, id, Edition::CURRENT);

+ let call_site_span = span_with_call_site_ctxt(db, span, id, Edition::CURRENT);

+ let call_site_span = span_with_call_site_ctxt(db, span, id, Edition::CURRENT);

+ ($span:ident $builder:ident = ) => {$crate::builtin::quote::__quote!(@PUNCT($span $builder) '=')};

+ use span::{Edition, SpanAnchor, SyntaxContextId, ROOT_ERASED_FILE_AST_ID};

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

+ SUBTREE $$ 937550:[email protected]#2 937550:[email protected]#2

+ IDENT hello 937550:[email protected]#2"#]]

+use span::{AstIdMap, Edition, EditionedFileId, Span, SyntaxContextData, SyntaxContextId};

+ fn syntax_context(&self, file: HirFileId, edition: Edition) -> SyntaxContextId;

+fn syntax_context(db: &dyn ExpandDatabase, file: HirFileId, edition: Edition) -> SyntaxContextId {

+ HirFileIdRepr::FileId(_) => SyntaxContextId::root(edition),

+ span_with_def_site_ctxt(db, span, actual_macro_call, loc.def.edition),

+ span_with_call_site_ctxt(db, span, actual_macro_call, loc.def.edition),

+ span_with_mixed_site_ctxt(db, span, actual_macro_call, loc.def.edition),

+ token_tree_to_syntax_node(db, &speculative_expansion.value, expand_to, loc.def.edition);

+ db,

+ span_with_def_site_ctxt(db, span, id, loc.def.edition),

+ span_with_call_site_ctxt(db, span, id, loc.def.edition),

+ span_with_mixed_site_ctxt(db, span, id, loc.def.edition),

+pub(crate) fn token_tree_to_syntax_node(

+ db: &dyn ExpandDatabase,

+ syntax_bridge::token_tree_to_syntax_node(

+ tt,

+ entry_point,

+ &mut |ctx| ctx.lookup(db).edition,

+ edition,

+ )

+ for edition in Edition::iter() {

+ db.intern_syntax_context(SyntaxContextData::root(edition));

+ }

+use span::{Edition, HirFileIdRepr, MacroCallId, Span, SyntaxContextId};

+ edition: Edition,

+ |s| s.ctx = apply_mark(db, s.ctx, call_id, self.transparency, self.edition),

+ let edition = ctx_edition(match id.file_id.repr() {

+ HirFileIdRepr::MacroFile(macro_file) => macro_file.macro_call_id.lookup(db).ctxt,

+ HirFileIdRepr::FileId(file) => SyntaxContextId::root(file.edition()),

+ });

+ Arc::new(DeclarativeMacroExpander { mac, transparency, edition })

+ (FileRange { file_id, range: self.value }, SyntaxContextId::root(file_id.edition()))

+ (loc.kind.original_call_range(db), SyntaxContextId::root(loc.def.edition))

+ HirFileIdRepr::FileId(file_id) => Some((

+ FileRange { file_id, range: self.value },

+ SyntaxContextId::root(file_id.edition()),

+ )),

+ ctx: SyntaxContextId::root(span::Edition::Edition2015),

+ // Skip the newly inserted replacement, we don't want to visit it.

+ i += replacement.len();

+ fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, mut expect: Expect) {

+ &mut |_| parser::Edition::CURRENT,

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

+pub fn span_with_def_site_ctxt(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ expn_id: MacroCallId,

+ edition: Edition,

+) -> Span {

+ span_with_ctxt_from_mark(db, span, expn_id, Transparency::Opaque, edition)

+pub fn span_with_call_site_ctxt(

+ db: &dyn ExpandDatabase,

+ span: Span,

+ expn_id: MacroCallId,

+ edition: Edition,

+) -> Span {

+ span_with_ctxt_from_mark(db, span, expn_id, Transparency::Transparent, edition)

+ edition: Edition,

+ span_with_ctxt_from_mark(db, span, expn_id, Transparency::SemiTransparent, edition)

+ edition: Edition,

+ Span {

+ ctx: apply_mark(db, SyntaxContextId::root(edition), expn_id, transparency, edition),

+ ..span

+ }

+ edition: Edition,

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

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

+ call_site_ctxt = apply_mark_internal(db, call_site_ctxt, call_id, transparency, edition);

+ apply_mark_internal(db, call_site_ctxt, call_id, transparency, edition)

+ edition: Edition,

+ (parent, call_id, transparency, edition),

+ edition,

+ (parent, call_id, transparency, edition),

+ edition,

+ edition,

+ const DISABLED: &str = "proc-macro-disabled";

+ const ATTR_EXP_DISABLED: &str = "attribute-expansion-disabled";

+ kind: RenderedExpandError::ATTR_EXP_DISABLED,

+ kind: RenderedExpandError::DISABLED,

+ ast::PathSegmentKind::SelfTypeKw => {

+ ModPath::from_segments(PathKind::Plain, Some(Name::new_symbol_root(sym::Self_.clone())))

+ }

+ (core::convert::From) => {};

+ (core::convert::TryFrom) => {};

+ (core::str::FromStr) => {};

+

+#[macro_export]

+macro_rules! __tool_path {

+ ($start:ident $(:: $seg:ident)*) => ({

+ $crate::mod_path::ModPath::from_segments($crate::mod_path::PathKind::Plain, vec![

+ $crate::name::Name::new_symbol_root(intern::sym::rust_analyzer.clone()), $crate::name::Name::new_symbol_root(intern::sym::$start.clone()), $($crate::name::Name::new_symbol_root(intern::sym::$seg.clone()),)*

+ ])

+ });

+}

+

+pub use crate::__tool_path as tool_path;

+/// Note that the rawness (`r#`) of names is not preserved. Names are always stored without a `r#` prefix.

+ debug_assert!(!text.starts_with("r#"));

+ pub fn new(text: &str, mut ctx: SyntaxContextId) -> Name {

+ // For comparisons etc. we remove the edition, because sometimes we search for some `Name`

+ // and we don't know which edition it came from.

+ // Can't do that for all `SyntaxContextId`s because it breaks Salsa.

+ ctx.remove_root_edition();

+ pub fn new_root(text: &str) -> Name {

+ // The edition doesn't matter for hygiene.

+ Self::new(text.trim_start_matches("r#"), SyntaxContextId::root(Edition::Edition2015))

+ }

+

+ let symbol = match idx {

+ 0 => sym::INTEGER_0.clone(),

+ 1 => sym::INTEGER_1.clone(),

+ 2 => sym::INTEGER_2.clone(),

+ 3 => sym::INTEGER_3.clone(),

+ 4 => sym::INTEGER_4.clone(),

+ 5 => sym::INTEGER_5.clone(),

+ 6 => sym::INTEGER_6.clone(),

+ 7 => sym::INTEGER_7.clone(),

+ 8 => sym::INTEGER_8.clone(),

+ 9 => sym::INTEGER_9.clone(),

+ 10 => sym::INTEGER_10.clone(),

+ 11 => sym::INTEGER_11.clone(),

+ 12 => sym::INTEGER_12.clone(),

+ 13 => sym::INTEGER_13.clone(),

+ 14 => sym::INTEGER_14.clone(),

+ 15 => sym::INTEGER_15.clone(),

+ _ => Symbol::intern(&idx.to_string()),

+ };

+ Name { symbol, ctx: () }

+ Self::new_text(lt.text().as_str().trim_start_matches("r#"))

+ ///

+ /// Do not use this for user-facing text, use `display` instead to handle editions properly.

+ // FIXME: Remove this

+ pub fn needs_escape(&self, edition: Edition) -> bool {

+ pub fn new_symbol(symbol: Symbol, ctx: SyntaxContextId) -> Self {

+ debug_assert!(!symbol.as_str().starts_with("r#"));

+ pub fn new_symbol_root(sym: Symbol) -> Self {

+ debug_assert!(!sym.as_str().starts_with("r#"));

+ // FIXME: Remove this

+ .filter_map(|(_, item)| match item {

+fn check_fail(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ error: impl FnOnce(ConstEvalError) -> bool,

+) {

+fn check_number(#[rust_analyzer::rust_fixture] ra_fixture: &str, answer: i128) {

+fn check_str(#[rust_analyzer::rust_fixture] ra_fixture: &str, answer: &str) {

+fn check_answer(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ check: impl FnOnce(&[u8], &MemoryMap),

+) {

+ let self_ty = trait_ref.self_type_parameter(Interner);

+

+ // if we are projection on a type parameter, check if the projection target has bounds

+ // itself, if so, we render them directly as `impl Bound` instead of the less useful

+ // `<Param as Trait>::Assoc`

+ if !f.display_target.is_source_code() {

+ if let TyKind::Placeholder(idx) = self_ty.kind(Interner) {

+ let db = f.db;

+ let id = from_placeholder_idx(db, *idx);

+ let generics = generics(db.upcast(), id.parent);

+

+ let substs = generics.placeholder_subst(db);

+ let bounds = db

+ .generic_predicates(id.parent)

+ .iter()

+ .map(|pred| pred.clone().substitute(Interner, &substs))

+ .filter(|wc| match wc.skip_binders() {

+ WhereClause::Implemented(tr) => {

+ match tr.self_type_parameter(Interner).kind(Interner) {

+ TyKind::Alias(AliasTy::Projection(proj)) => proj == self,

+ _ => false,

+ }

+ }

+ WhereClause::TypeOutlives(t) => match t.ty.kind(Interner) {

+ TyKind::Alias(AliasTy::Projection(proj)) => proj == self,

+ _ => false,

+ },

+ // We shouldn't be here if these exist

+ WhereClause::AliasEq(_) => false,

+ WhereClause::LifetimeOutlives(_) => false,

+ })

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

+ if !bounds.is_empty() {

+ return write_bounds_like_dyn_trait_with_prefix(

+ f,

+ "impl",

+ Either::Left(

+ &TyKind::Alias(AliasTy::Projection(self.clone())).intern(Interner),

+ ),

+ &bounds,

+ SizedByDefault::NotSized,

+ );

+ };

+ }

+ }

+

+ self_ty.hir_fmt(f)?;

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+fn eval_goal(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ minicore: &str,

+) -> Result<Arc<Layout>, LayoutError> {

+fn eval_expr(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ minicore: &str,

+) -> Result<Arc<Layout>, LayoutError> {

+fn check_size_and_align(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ minicore: &str,

+ size: u64,

+ align: u64,

+) {

+fn check_size_and_align_expr(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ minicore: &str,

+ size: u64,

+ align: u64,

+) {

+fn check_fail(#[rust_analyzer::rust_fixture] ra_fixture: &str, e: LayoutError) {

+ let (resolution, remaining_index, _, prefix_info) =

+ self.resolver.resolve_path_in_type_ns_with_prefix_info(self.db.upcast(), path)?;

+ let (module_segments, resolved_segment_idx, enum_segment) = match remaining_index {

+ None if prefix_info.enum_variant => {

+ (segments.strip_last_two(), segments.len() - 1, Some(segments.len() - 2))

+ }

+ None => (segments.strip_last(), segments.len() - 1, None),

+ Some(i) => (segments.take(i - 1), i - 1, None),

+ if let Some(enum_segment) = enum_segment {

+ if segments.get(enum_segment).is_some_and(|it| it.args_and_bindings.is_some())

+ && segments.get(enum_segment + 1).is_some_and(|it| it.args_and_bindings.is_some())

+ {

+ on_diagnostic(

+ self,

+ PathLoweringDiagnostic::GenericArgsProhibited {

+ segment: (enum_segment + 1) as u32,

+ reason: GenericArgsProhibitedReason::EnumVariant,

+ },

+ );

+ }

+ }

+

+ segments.get(resolved_segment_idx).expect("should have resolved segment"),

+ let item = impl_data.items.iter().find_map(|(n, it)| match *it {

+ AssocItemId::FunctionId(f) => (n == name).then_some(AssocItemId::FunctionId(f)),

+ AssocItemId::ConstId(c) => (n == name).then_some(AssocItemId::ConstId(c)),

+ && impl_data.items.iter().all(|&(_, assoc)| match assoc {

+ for &(ref item_name, item) in table.db.impl_data(impl_id).items.iter() {

+ item_name,

+ item_name: &Name,

+ item_name,

+ check_that!(name.is_none_or(|n| n == item_name));

+ item_name: &Name,

+ check_that!(name.is_none_or(|n| n == item_name));

+

+fn check_pass(#[rust_analyzer::rust_fixture] ra_fixture: &str) {

+fn check_pass_and_stdio(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ expected_stdout: &str,

+ expected_stderr: &str,

+) {

+fn check_panic(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected_panic: &str) {

+fn check_types(#[rust_analyzer::rust_fixture] ra_fixture: &str) {

+fn check_types_source_code(#[rust_analyzer::rust_fixture] ra_fixture: &str) {

+fn check_no_mismatches(#[rust_analyzer::rust_fixture] ra_fixture: &str) {

+fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str) {

+fn check_impl(

+ #[rust_analyzer::rust_fixture] ra_fixture: &str,

+ allow_none: bool,

+ only_types: bool,

+ display_source: bool,

+) {

+fn infer(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> String {

+ for &(_, item) in impl_data.items.iter() {

+fn check_infer(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+fn check_infer_with_mismatches(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+fn check_closure_captures(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {

+

+#[test]

+fn tool_attr_skip() {

+ check_no_mismatches(

+ r#"

+#[rust_analyzer::skip]

+async fn foo(a: (), b: i32) -> u32 {

+ 0 + 1 + b()

+}

+ "#,

+ );

+}

+ fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected: Expect) {

+indexmap.workspace = true

+impl HasAttrs for crate::Crate {

+ fn attrs(self, db: &dyn HirDatabase) -> AttrsWithOwner {

+ let def = AttrDefId::ModuleId(self.root_module().id);

+ AttrsWithOwner::new(db.upcast(), def)

+ }

+ fn attr_id(self) -> AttrDefId {

+ AttrDefId::ModuleId(self.root_module().id)

+ }

+}

+

+ Err(_) => Name::new_root(segment.split_once('<').map_or(segment, |it| it.0)),

+ Adt, AsAssocItem, AssocItem, AssocItemContainer, Const, ConstParam, Crate, Enum,

+ ExternCrateDecl, Field, Function, GenericParam, HasCrate, HasVisibility, Impl, LifetimeParam,

+ Macro, Module, SelfParam, Static, Struct, Trait, TraitAlias, TraitRef, TupleField, TyBuilder,

+ Type, TypeAlias, TypeOrConstParam, TypeParam, Union, Variant,

+ match self.parent(f.db) {

+ Some(m) => write_visibility(m.id, self.visibility(f.db), f)?,

+ None => {

+ return match self.krate(f.db).display_name(f.db) {

+ Some(name) => write!(f, "extern crate {name}"),

+ None => f.write_str("extern crate {unknown}"),

+ }

+ }

+ }

+ None => f.write_str("mod {unknown}"),

+ }

+ }

+}

+

+impl HirDisplay for Crate {

+ fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {

+ match self.display_name(f.db) {

+ Some(name) => write!(f, "extern crate {name}"),

+ None => f.write_str("extern crate {unknown}"),

+ AdtId, AssocItemId, AssocItemLoc, AttrDefId, CallableDefId, ConstId, ConstParamId,

+ CrateRootModuleId, DefWithBodyId, EnumId, EnumVariantId, ExternCrateId, FunctionId,

+ GenericDefId, GenericParamId, HasModule, ImplId, InTypeConstId, ItemContainerId,

+ LifetimeParamId, LocalFieldId, Lookup, MacroExpander, MacroId, ModuleId, StaticId, StructId,

+ SyntheticSyntax, TraitAliasId, TupleId, TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,

+use span::{Edition, EditionedFileId, FileId, MacroCallId};

+ {ModuleDefId, TraitId},

+ impl_assoc_items_scratch.extend(db.impl_data(impl_def.id).items.iter().cloned());

+ .filter(|(name, id)| {

+ .map(|(name, item)| (name.clone(), AssocItem::from(*item)));

+ !impl_assoc_items_scratch.iter().any(|(impl_name, impl_item)| {

+ for &(_, item) in db.impl_data(impl_def.id).items.iter() {

+ pub fn is_proc_macro(self) -> bool {

+ matches!(self.id, MacroId::ProcMacroId(_))

+ }

+

+ MacroId::MacroRulesId(it) => {

+ matches!(it.lookup(db.upcast()).expander, MacroExpander::BuiltInEager(eager) if eager.is_env_or_option_env())

+ }

+ MacroId::ProcMacroId(_) => false,

+ match self.id {

+ MacroId::Macro2Id(it) => {

+ matches!(it.lookup(db.upcast()).expander, MacroExpander::BuiltIn(m) if m.is_asm())

+ }

+ MacroId::MacroRulesId(it) => {

+ matches!(it.lookup(db.upcast()).expander, MacroExpander::BuiltIn(m) if m.is_asm())

+ }

+ MacroId::ProcMacroId(_) => false,

+ }

+

+ pub fn krate(&self) -> Crate {

+ Crate { id: self.krate }

+ }

+ db.impl_data(self.id).items.iter().map(|&(_, it)| it.into()).collect()

+ pub fn add_reference(&self, mutability: Mutability) -> Type {

+ let ty_mutability = match mutability {

+ Mutability::Shared => hir_ty::Mutability::Not,

+ Mutability::Mut => hir_ty::Mutability::Mut,

+ };

+ self.derived(TyKind::Ref(ty_mutability, error_lifetime(), self.ty.clone()).intern(Interner))

+ }

+

+ /// `std::future::Future` and returns the `Output` associated type.

+ pub fn into_future_output(&self, db: &dyn HirDatabase) -> Option<Type> {

+ })?;

+ if !method_resolution::implements_trait_unique(&canonical_ty, db, &self.env, trait_) {

+ return None;

+ }

+

+ let output_assoc_type = db

+ .trait_data(trait_)

+ .associated_type_by_name(&Name::new_symbol_root(sym::Output.clone()))?;

+ self.normalize_trait_assoc_type(db, &[], output_assoc_type.into())

+ .associated_type_by_name(&Name::new_symbol_root(sym::Item.clone()))?;

+ /// Resolves the projection `<Self as IntoIterator>::IntoIter` and returns the resulting type

+ pub fn into_iterator_iter(self, db: &dyn HirDatabase) -> Option<Type> {

+ let trait_ = db.lang_item(self.env.krate, LangItem::IntoIterIntoIter).and_then(|it| {

+ let into_iter_fn = it.as_function()?;

+ let assoc_item = as_assoc_item(db, AssocItem::Function, into_iter_fn)?;

+ let into_iter_trait = assoc_item.container_or_implemented_trait(db)?;

+ Some(into_iter_trait.id)

+ })?;

+

+ let canonical_ty =

+ Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(Interner) };

+ if !method_resolution::implements_trait_unique(&canonical_ty, db, &self.env, trait_) {

+ return None;

+ }

+

+ let into_iter_assoc_type = db

+ .trait_data(trait_)

+ .associated_type_by_name(&Name::new_symbol_root(sym::IntoIter.clone()))?;

+ self.normalize_trait_assoc_type(db, &[], into_iter_assoc_type.into())

+ }

+

+ for &(_, item) in db.impl_data(*impl_def).items.iter() {

+ cb(type_.derived(ty.clone()));

+ AstNode, AstToken, Direction, SyntaxKind, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange,

+ TextSize,

+ SemanticsImpl { db, s2d_cache: Default::default(), macro_call_cache: Default::default() }

+ .map(|call| macro_call_to_macro_id(ctx, call?).map(|id| Macro { id }))

+ .get_or_insert_expansion(ctx.db, macro_file)

+ stack.push((

+ file_id.into(),

+ smallvec![(token, SyntaxContextId::root(file_id.edition()))],

+ ));

+ let expansion_info = ctx.cache.get_or_insert_expansion(ctx.db, macro_file);

+ let src = self.wrap_node_infile(label.clone());

+ let (parent, label_id) = self.with_ctx(|ctx| ctx.label_ref_to_def(src.as_ref()))?;

+ pub fn resolve_known_blanket_dual_impls(&self, call: &ast::MethodCallExpr) -> Option<Function> {

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

+ }

+

+ .and_then(|call| macro_call_to_macro_id(ctx, call))

+ macro_call_to_macro_id(ctx, macro_call_id)

+ segments: impl IntoIterator<Item = Name>,

+ &ModPath::from_segments(hir_def::path::PathKind::Plain, segments),

+ SourceToDefCache::cache(

+ &mut self.s2d_cache.borrow_mut().root_to_file_cache,

+ root_node,

+ file_id,

+ );

+ let cache = self.s2d_cache.borrow();

+ cache.root_to_file_cache.get(root_node).copied()

+ Make sure to only query nodes derived from this instance of Semantics.\n\

+ self.s2d_cache

+ .root_to_file_cache

+ let expansion_info = ctx.cache.get_or_insert_expansion(ctx.db, macro_file);

+ let expansion_info = ctx.cache.get_or_insert_expansion(ctx.db, macro_file);

+ data.items.iter().for_each(|&(_, item)| {

+use crate::{db::HirDatabase, semantics::child_by_source::ChildBySource, InFile, InlineAsmOperand};

+ /// Rootnode to HirFileId cache

+ pub(super) root_to_file_cache: FxHashMap<SyntaxNode, HirFileId>,

+ pub(super) fn cache(

+ root_to_file_cache: &mut FxHashMap<SyntaxNode, HirFileId>,

+ root_node: SyntaxNode,

+ file_id: HirFileId,

+ ) {

+ assert!(root_node.parent().is_none());

+ let prev = root_to_file_cache.insert(root_node, file_id);

+ assert!(prev.is_none() || prev == Some(file_id));

+ }

+

+ db: &dyn HirDatabase,

+ let exp_info = macro_file.expansion_info(db.upcast());

+ Self::cache(&mut self.root_to_file_cache, value, file_id.into());

+ let expansion_info = this.cache.get_or_insert_expansion(this.db, macro_file);

+ // If the method is into(), try_into(), parse(), resolve it to from, try_from, from_str.

+ pub(crate) fn resolve_known_blanket_dual_impls(

+ &self,

+ db: &dyn HirDatabase,

+ call: &ast::MethodCallExpr,

+ ) -> Option<Function> {

+ // e.g. if the method call is let b = a.into(),

+ // - receiver_type is A (type of a)

+ // - return_type is B (type of b)

+ // We will find the definition of B::from(a: A).

+ let callable = self.resolve_method_call_as_callable(db, call)?;

+ let (_, receiver_type) = callable.receiver_param(db)?;

+ let return_type = callable.return_type();

+ let (search_method, substs) = match call.name_ref()?.text().as_str() {

+ "into" => {

+ let trait_ =

+ self.resolver.resolve_known_trait(db.upcast(), &path![core::convert::From])?;

+ (

+ self.trait_fn(db, trait_, "from")?,

+ hir_ty::TyBuilder::subst_for_def(db, trait_, None)

+ .push(return_type.ty)

+ .push(receiver_type.ty)

+ .build(),

+ )

+ }

+ "try_into" => {

+ let trait_ = self

+ .resolver

+ .resolve_known_trait(db.upcast(), &path![core::convert::TryFrom])?;

+ (

+ self.trait_fn(db, trait_, "try_from")?,

+ hir_ty::TyBuilder::subst_for_def(db, trait_, None)

+ // If the method is try_into() or parse(), return_type is Result<T, Error>.

+ // Get T from type arguments of Result<T, Error>.

+ .push(return_type.type_arguments().next()?.ty)

+ .push(receiver_type.ty)

+ .build(),

+ )

+ }

+ "parse" => {

+ let trait_ =

+ self.resolver.resolve_known_trait(db.upcast(), &path![core::str::FromStr])?;

+ (

+ self.trait_fn(db, trait_, "from_str")?,

+ hir_ty::TyBuilder::subst_for_def(db, trait_, None)

+ .push(return_type.type_arguments().next()?.ty)

+ .build(),

+ )

+ }

+ _ => return None,

+ };

+

+ let found_method = self.resolve_impl_method_or_trait_def(db, search_method, substs);

+ // If found_method == search_method, the method in trait itself is resolved.

+ // It means the blanket dual impl is not found.

+ if found_method == search_method {

+ None

+ } else {

+ Some(found_method.into())

+ }

+ }

+

+ fn trait_fn(

+ &self,

+ db: &dyn HirDatabase,

+ trait_id: TraitId,

+ method_name: &str,

+ ) -> Option<FunctionId> {

+ db.trait_data(trait_id).items.iter().find_map(|(item_name, item)| match item {

+ AssocItemId::FunctionId(t) if item_name.as_str() == method_name => Some(*t),

+ _ => None,

+ })

+ }

+

+use either::Either;

+ item_scope::{ImportId, ImportOrExternCrate},

+ per_ns::Item,

+ visibility::{Visibility, VisibilityExplicitness},

+ AdtId, AssocItemId, DefWithBodyId, ExternCrateId, HasModule, ImplId, Lookup, MacroId,

+ ModuleDefId, ModuleId, TraitId,

+use hir_expand::{name::Name, HirFileId};

+use intern::Symbol;

+use rustc_hash::FxHashMap;

+pub type FxIndexSet<T> = indexmap::IndexSet<T, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;

+

+ pub name: Symbol,

+ pub name_ptr: AstPtr<Either<syntax::ast::Name, syntax::ast::NameRef>>,

+ symbols: FxIndexSet<FileSymbol>,

+ pub fn finish(self) -> Box<[FileSymbol]> {

+ self.symbols.into_iter().collect()

+ pub fn collect_module(db: &dyn HirDatabase, module: Module) -> Box<[FileSymbol]> {

+ let push_decl = |this: &mut Self, def, name| {

+ match def {

+ ModuleDefId::ModuleId(id) => this.push_module(id, name),

+ this.push_decl(id, name, false);

+ this.collect_from_body(id);

+ ModuleDefId::AdtId(AdtId::StructId(id)) => this.push_decl(id, name, false),

+ ModuleDefId::AdtId(AdtId::EnumId(id)) => this.push_decl(id, name, false),

+ ModuleDefId::AdtId(AdtId::UnionId(id)) => this.push_decl(id, name, false),

+ this.push_decl(id, name, false);

+ this.collect_from_body(id);

+ this.push_decl(id, name, false);

+ this.collect_from_body(id);

+ this.push_decl(id, name, false);

+ this.collect_from_trait(id);

+ this.push_decl(id, name, false);

+ this.push_decl(id, name, false);

+ MacroId::Macro2Id(id) => this.push_decl(id, name, false),

+ MacroId::MacroRulesId(id) => this.push_decl(id, name, false),

+ MacroId::ProcMacroId(id) => this.push_decl(id, name, false),

+ };

+ // Nested trees are very common, so a cache here will hit a lot.

+ let import_child_source_cache = &mut FxHashMap::default();

+

+ let mut push_import = |this: &mut Self, i: ImportId, name: &Name, def: ModuleDefId| {

+ let source = import_child_source_cache

+ .entry(i.import)

+ .or_insert_with(|| i.import.child_source(this.db.upcast()));

+ let Some(use_tree_src) = source.value.get(i.idx) else { return };

+ let Some(name_ptr) = use_tree_src

+ .rename()

+ .and_then(|rename| rename.name())

+ .map(Either::Left)

+ .or_else(|| use_tree_src.path()?.segment()?.name_ref().map(Either::Right))

+ .map(|it| AstPtr::new(&it))

+ else {

+ return;

+ };

+ let dec_loc = DeclarationLocation {

+ hir_file_id: source.file_id,

+ ptr: SyntaxNodePtr::new(use_tree_src.syntax()),

+ name_ptr,

+ };

+ this.symbols.insert(FileSymbol {

+ name: name.symbol().clone(),

+ def: def.into(),

+ container_name: this.current_container_name.clone(),

+ loc: dec_loc,

+ is_alias: false,

+ is_assoc: false,

+ });

+ };

+ let push_extern_crate =

+ |this: &mut Self, i: ExternCrateId, name: &Name, def: ModuleDefId| {

+ let loc = i.lookup(this.db.upcast());

+ let source = loc.source(this.db.upcast());

+ let Some(name_ptr) = source

+ .value

+ .rename()

+ .and_then(|rename| rename.name())

+ .map(Either::Left)

+ .or_else(|| source.value.name_ref().map(Either::Right))

+ .map(|it| AstPtr::new(&it))

+ else {

+ return;

+ };

+ ptr: SyntaxNodePtr::new(source.value.syntax()),

+ name_ptr,

+ this.symbols.insert(FileSymbol {

+ name: name.symbol().clone(),

+ def: def.into(),

+ container_name: this.current_container_name.clone(),

+ };

+

+ let is_explicit_import = |vis| {

+ match vis {

+ Visibility::Module(_, VisibilityExplicitness::Explicit) => true,

+ Visibility::Module(_, VisibilityExplicitness::Implicit) => {

+ // consider imports in the crate root explicit, as these are visibly

+ // crate-wide anyways

+ module_id.is_crate_root()

+ }

+ Visibility::Public => true,

+ }

+ };

+

+ let def_map = module_id.def_map(self.db.upcast());

+ let scope = &def_map[module_id.local_id].scope;

+

+ for impl_id in scope.impls() {

+ self.collect_from_impl(impl_id);

+ }

+

+ for (name, Item { def, vis, import }) in scope.types() {

+ if let Some(i) = import {

+ if is_explicit_import(vis) {

+ match i {

+ ImportOrExternCrate::Import(i) => push_import(self, i, name, def),

+ ImportOrExternCrate::ExternCrate(i) => {

+ push_extern_crate(self, i, name, def)

+ }

+ }

+ }

+ continue;

+ }

+ // self is a declaration

+ push_decl(self, def, name)

+ }

+

+ for (name, Item { def, vis, import }) in scope.macros() {

+ if let Some(i) = import {

+ if is_explicit_import(vis) {

+ push_import(self, i, name, def.into());

+ }

+ continue;

+ }

+ // self is a declaration

+ push_decl(self, def.into(), name)

+ }

+

+ for (name, Item { def, vis, import }) in scope.values() {

+ if let Some(i) = import {

+ if is_explicit_import(vis) {

+ push_import(self, i, name, def);

+ }

+ continue;

+ }

+ // self is a declaration

+ push_decl(self, def, name)

+ for (name, id) in scope.legacy_macros() {

+ MacroId::Macro2Id(id) => self.push_decl(id, name, false),

+ MacroId::MacroRulesId(id) => self.push_decl(id, name, false),

+ MacroId::ProcMacroId(id) => self.push_decl(id, name, false),

+ for &(ref name, assoc_item_id) in &impl_data.items {

+ s.push_assoc_item(assoc_item_id, name)

+ for &(ref name, assoc_item_id) in &trait_data.items {

+ s.push_assoc_item(assoc_item_id, name);

+ fn push_assoc_item(&mut self, assoc_item_id: AssocItemId, name: &Name) {

+ AssocItemId::FunctionId(id) => self.push_decl(id, name, true),

+ AssocItemId::ConstId(id) => self.push_decl(id, name, true),

+ AssocItemId::TypeAliasId(id) => self.push_decl(id, name, true),

+ fn push_decl<'db, L>(&mut self, id: L, name: &Name, is_assoc: bool)

+ name_ptr: AstPtr::new(&name_node).wrap_left(),

+ self.symbols.insert(FileSymbol {

+ name: alias.clone(),

+ self.symbols.insert(FileSymbol {

+ name: name.symbol().clone(),

+ fn push_module(&mut self, module_id: ModuleId, name: &Name) {

+ name_ptr: AstPtr::new(&name_node).wrap_left(),

+ self.symbols.insert(FileSymbol {

+ name: alias.clone(),

+ self.symbols.insert(FileSymbol {

+ name: name.symbol().clone(),

+ pub(crate) fn source_file(&self) -> &SourceFile {

+ &self.source_file

+ }

+

+ make::match_arm(pat, None, make::ext::expr_todo()).clone_for_update()

+ let arm =

+ make::match_arm(make::wildcard_pat().into(), None, make::ext::expr_todo())

+ .clone_for_update();

+ make.generic_arg_list(args, true)

+ make::expr_prefix(T![!], make::expr_paren(expr)).into()

+ .into()

+ make::expr_prefix(T![*], capture_name).into()

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

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

+ pub(crate) fn check_in_place_assist(

+ #[rust_analyzer::rust_fixture] ra_fixture_before: &str,

+ #[rust_analyzer::rust_fixture] ra_fixture_after: &str,

+ ) {

+ pub(crate) fn check_sub_pattern_assist(

+ #[rust_analyzer::rust_fixture] ra_fixture_before: &str,

+ #[rust_analyzer::rust_fixture] ra_fixture_after: &str,

+ ) {

+ make::expr_if(condition.into(), block, None).into()

+ make::expr_if(cond.into(), then, None).into()

+ make::match_arm(pat.into(), None, value)

+ make::match_arm(pat, None, none.make_result_handler(None))

+ make::expr_match(call_expr, arms).into()

+ make::match_arm(pat.into(), None, value)

+ make::match_arm(pat.into(), None, err.make_result_handler(Some(value)))

+ make::expr_match(call_expr, arms).into()

+ tail_expr = Some(expr.into());

+ let block = with_default_tail_expr(block, make::ext::expr_unit());

+ make::arg_list([make::ext::expr_unit()]),

+ make::arg_list([make::ext::expr_unit()]),

+ let expr = arg_expr.unwrap_or_else(make::ext::expr_unit);

+ let args = make::arg_list([expr]);

+ let expr = arg_expr.unwrap_or_else(make::ext::expr_unit);

+ let args = make::arg_list([expr]);

+ algo::ancestors_at_offset,

+ } else if let Some(expr) = ancestors_at_offset(ctx.source_file().syntax(), ctx.offset())

+ .next()

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

+ {

+ if$0 true {

+ }

+ if$0 true {

+ }

+ if$0 true {

+ }

+ fn check_not_applicable(#[rust_analyzer::rust_fixture] ra_fixture: &str) {

+ let target_crate_id = ctx.sema.file_to_module_def(ctx.file_id())?.krate().into();

+ |builder| {

+ let expanded = ctx.sema.parse_or_expand(macro_call.as_file());

+ let span_map = ctx.sema.db.expansion_span_map(macro_call.as_macro_file());

+ // Don't call `prettify_macro_expansion()` outside the actual assist action; it does some heavy rowan tree manipulation,

+ // which can be very costly for big macros when it is done *even without the assist being invoked*.

+ let expanded = prettify_macro_expansion(ctx.db(), expanded, &span_map, target_crate_id);

+ builder.replace(text_range, expanded.to_string())

+ },

+ edit.replace_ast(arm_expr, if_expr.into());

+ _ => (macro_call.syntax().text_range(), Some(make::ext::expr_unit())),

+ (macro_call.syntax().text_range(), Some(expr.into()))

+ fn check(

+ #[rust_analyzer::rust_fixture] ra_fixture_before: &str,

+ #[rust_analyzer::rust_fixture] ra_fixture_after: &str,

+ ) {

+use std::iter::successors;

+ ast::{self, edit::IndentLevel, edit_in_place::Indent, syntax_factory::SyntaxFactory, HasName},

+ move |builder| {

+ let make = SyntaxFactory::new();

+ let else_arm = make_else_arm(ctx, &make, else_block, &cond_bodies);

+ let body = make.block_expr(body.statements(), body.tail_expr());

+ body.indent(IndentLevel::from(1));

+ let body = unwrap_trivial_block(body);

+ Either::Left(pat) => make.match_arm(pat, None, body),

+ Either::Right(_) if !pat_seen => {

+ make.match_arm(make.literal_pat("true").into(), None, body)

+ Either::Right(expr) => make.match_arm(

+ make.wildcard_pat().into(),

+ Some(make.match_guard(expr)),

+ body,

+ let arms = cond_bodies.into_iter().map(make_match_arm).chain([else_arm]);

+ let match_expr = make.expr_match(scrutinee_to_be_expr, make.match_arm_list(arms));

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

+ match_expr.into()

+ make.block_expr([], Some(match_expr)).into()

+

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

+ editor.replace(if_expr.syntax(), expr.syntax());

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

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

+ make: &SyntaxFactory,

+ [(Either::Right(_), _)] => make.literal_pat("false").into(),

+ make.wildcard_pat().into()

+ None => make.wildcard_pat().into(),

+ _ => make.wildcard_pat().into(),

+ [(Either::Right(_), _)] => make.literal_pat("false").into(),

+ _ => make.wildcard_pat().into(),

+ (pattern, make.expr_unit())

+ make.match_arm(pattern, None, expr)

+ match_expr.syntax().text_range(),

+ move |builder| {

+ let make = SyntaxFactory::new();

+ let make_block_expr = |expr: ast::Expr| {

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

+ };