};

use intern::Symbol;

use rustc_hash::FxHashMap;

use crate::{HasCrate, Module, ModuleDef, Semantics};

pub name: Symbol,

pub def: ModuleDef,

pub loc: DeclarationLocation,

/// Whether this symbol is a doc alias for the original symbol.

pub is_alias: bool,

pub is_assoc: bool,

db: &'a dyn HirDatabase,

symbols: FxIndexSet<FileSymbol>,

work: Vec<SymbolCollectorWork>,

}

/// Given a [`ModuleId`] and a [`HirDatabase`], use the DefMap for the module's crate to collect

tracing::info!(?work, "SymbolCollector::do_work");

self.db.unwind_if_revision_cancelled();

self.with_container_name(parent_name, |s| s.collect_from_module(work.module_id));

}

}

ModuleDefId::AdtId(AdtId::EnumId(id)) => {

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

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

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

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

)

.to_smolstr(),

);

for &(ref name, assoc_item_id) in &impl_id.impl_items(self.db).items {

s.push_assoc_item(assoc_item_id, name, None)

}

fn collect_from_trait(&mut self, trait_id: TraitId, trait_do_not_complete: Complete) {

let trait_data = self.db.trait_signature(trait_id);

for &(ref name, assoc_item_id) in &trait_id.trait_items(self.db).items {

s.push_assoc_item(assoc_item_id, name, Some(trait_do_not_complete));

}

});

}

if let Some(container_name) = container_name {

let prev = self.current_container_name.replace(container_name);

f(self);

use std::hash::{BuildHasher, Hash};

use smallvec::SmallVec;

use span::{TextRange, TextSize};

use syntax::{

f64,

&str,

String,

SmolStr,

Documentation,

SymbolKind,

Some(NavigationTarget {

file_id,

full_range: TextRange::new(0.into(), size),

alias: None,

focus_range: None,

kind: None,

let value_range = value.syntax().text_range();

let navs = navigation_target::orig_range_with_focus_r(db, file_id, value_range, focus_range);

navs.map(|(hir::FileRangeWrapper { file_id, range }, focus_range)| {

})

}

use crate::{GotoDefinitionConfig, fixture};

use ide_db::{FileRange, MiniCore};

use itertools::Itertools;

const TEST_CONFIG: GotoDefinitionConfig<'_> =

GotoDefinitionConfig { minicore: MiniCore::default() };

let Some(target) = navs.into_iter().next() else {

panic!("expected single navigation target but encountered none");

};

}

#[test]

use either::Either;

use hir::{

AssocItem, Crate, FieldSource, HasContainer, HasCrate, HasSource, HirDisplay, HirFileId,

};

use ide_db::{

FileId, FileRange, RootDatabase, SymbolKind,

famous_defs::FamousDefs,

ra_fixture::UpmapFromRaFixture,

};

use stdx::never;

use syntax::{

ast::{self, HasName},

};

/// `NavigationTarget` represents an element in the editor's UI which you can

///

/// This range must be contained within [`Self::full_range`].

pub focus_range: Option<TextRange>,

pub kind: Option<SymbolKind>,

pub description: Option<String>,

pub docs: Option<Documentation>,

/// In addition to a `name` field, a `NavigationTarget` may also be aliased

/// In such cases we want a `NavigationTarget` to be accessible by its alias

}

impl fmt::Debug for NavigationTarget {

db: &RootDatabase,

module: hir::Module,

) -> UpmappingResult<NavigationTarget> {

match module.declaration_source(db) {

Some(InFile { value, file_id }) => {

orig_range_with_focus(db, file_id, value.syntax(), value.name()).map(

InFile { file_id, value }: InFile<&dyn ast::HasName>,

kind: SymbolKind,

) -> UpmappingResult<NavigationTarget> {

orig_range_with_focus(db, file_id, value.syntax(), value.name()).map(

|(FileRange { file_id, range: full_range }, focus_range)| {

pub(crate) fn from_syntax(

file_id: FileId,

focus_range: Option<TextRange>,

full_range: TextRange,

kind: SymbolKind,

sema: &Semantics<'_, RootDatabase>,

) -> Option<UpmappingResult<NavigationTarget>> {

let db = sema.db;

let display_target = self.def.krate(db).to_display_target(db);

Some(

orig_range_with_focus_r(

.map(|(FileRange { file_id, range: full_range }, focus_range)| {

NavigationTarget {

file_id,

kind: Some(self.def.into()),

full_range,

focus_range,

pub(crate) trait ToNavFromAst: Sized {

const KIND: SymbolKind;

_ = db;

None

}

}

match t.container(db) {

// FIXME: Handle owners of blocks correctly here

_ => None,

}

}

impl ToNavFromAst for hir::Function {

const KIND: SymbolKind = SymbolKind::Function;

}

}

impl ToNavFromAst for hir::Const {

const KIND: SymbolKind = SymbolKind::Const;

}

}

impl ToNavFromAst for hir::Static {

const KIND: SymbolKind = SymbolKind::Static;

}

}

impl ToNavFromAst for hir::Struct {

const KIND: SymbolKind = SymbolKind::Struct;

}

}

impl ToNavFromAst for hir::Enum {

const KIND: SymbolKind = SymbolKind::Enum;

}

}

impl ToNavFromAst for hir::Variant {

}

impl ToNavFromAst for hir::Union {

const KIND: SymbolKind = SymbolKind::Union;

}

}

impl ToNavFromAst for hir::TypeAlias {

const KIND: SymbolKind = SymbolKind::TypeAlias;

}

}

impl ToNavFromAst for hir::Trait {

const KIND: SymbolKind = SymbolKind::Trait;

}

}

impl ToNav for hir::Module {

fn to_nav(&self, db: &RootDatabase) -> UpmappingResult<NavigationTarget> {

let InFile { file_id, value } = self.definition_source(db);

let (syntax, focus) = match &value {

ModuleSource::SourceFile(node) => (node.syntax(), None),

ModuleSource::Module(node) => (node.syntax(), node.name()),

|(FileRange { file_id, range: full_range }, focus_range)| {

NavigationTarget::from_syntax(

file_id,

focus_range,

full_range,

SymbolKind::Impl,

.rename()

.map_or_else(|| value.name_ref().map(Either::Left), |it| it.name().map(Either::Right));

let krate = self.module(db).krate();

Some(orig_range_with_focus(db, file_id, value.syntax(), focus).map(

|(FileRange { file_id, range: full_range }, focus_range)| {

let mut res = NavigationTarget::from_syntax(

file_id,

focus_range,

full_range,

SymbolKind::Module,

res.docs = self.docs(db);

res.description = Some(self.display(db, krate.to_display_target(db)).to_string());

res

},

))

|(FileRange { file_id, range: full_range }, focus_range)| {

NavigationTarget::from_syntax(

file_id,

focus_range,

full_range,

SymbolKind::Field,

Either::Left(bind_pat) => (bind_pat.syntax(), bind_pat.name()),

Either::Right(it) => (it.syntax(), it.name()),

};

orig_range_with_focus(db, file_id, node, name).map(

|(FileRange { file_id, range: full_range }, focus_range)| {

let kind = if local.is_self(db) {

SymbolKind::SelfParam

} else if local.is_param(db) {

) -> Option<UpmappingResult<NavigationTarget>> {

let db = sema.db;

let InFile { file_id, value } = self.source(db)?;

Some(orig_range_with_focus(db, file_id, value.syntax(), value.lifetime()).map(

|(FileRange { file_id, range: full_range }, focus_range)| NavigationTarget {

) -> Option<UpmappingResult<NavigationTarget>> {

let db = sema.db;

let InFile { file_id, value } = self.merge().source(db)?;

let value = match value {

Either::Left(ast::TypeOrConstParam::Type(x)) => Either::Left(x),

) -> Option<UpmappingResult<NavigationTarget>> {

let db = sema.db;

let InFile { file_id, value } = self.source(db)?;

Some(orig_range(db, file_id, value.syntax()).map(

|(FileRange { file_id, range: full_range }, focus_range)| NavigationTarget {

) -> Option<UpmappingResult<NavigationTarget>> {

let db = sema.db;

let InFile { file_id, value } = self.merge().source(db)?;

let value = match value {

Either::Left(ast::TypeOrConstParam::Const(x)) => x,

let InFile { file_id, value } = &self.source(db)?;

let file_id = *file_id;

Some(orig_range_with_focus(db, file_id, value.syntax(), value.name()).map(

},

))

}

use self$0;

"#,

expect![[r#"

FileId(0) 4..8 import

"#]],

}

"#,

expect![[r#"

FileId(0) 113..121

"#]],

}

"#,

expect![[r#"

FileId(0) 18..23

FileId(0) 44..49

.cmp(&nav_b.focus_range.map_or_else(t_0, |it| it.start()))

})

.then_with(|| kind.disc().cmp(&kind_b.disc()))

}

fn find_related_tests(

"#,

expect![[r#"

[

"(Bin, NavigationTarget { file_id: FileId(0), full_range: 1..13, focus_range: 4..8, name: \"main\", kind: Function })",

"(Bin, NavigationTarget { file_id: FileId(0), full_range: 15..76, focus_range: 42..71, name: \"__cortex_m_rt_main_trampoline\", kind: Function })",

"(Bin, NavigationTarget { file_id: FileId(0), full_range: 78..154, focus_range: 113..149, name: \"__cortex_m_rt_main_trampoline_unsafe\", kind: Function })",

"#,

expect![[r#"

[

"(Test, NavigationTarget { file_id: FileId(0), full_range: 1..50, focus_range: 36..45, name: \"test_foo1\", kind: Function }, Atom(KeyValue { key: \"feature\", value: \"foo\" }))",

]

"#]],

"#,

expect![[r#"

[

"(Test, NavigationTarget { file_id: FileId(0), full_range: 1..72, focus_range: 58..67, name: \"test_foo1\", kind: Function }, All([Atom(KeyValue { key: \"feature\", value: \"foo\" }), Atom(KeyValue { key: \"feature\", value: \"bar\" })]))",

]

"#]],

"#,

expect![[r#"

[

"(TestMod, NavigationTarget { file_id: FileId(0), full_range: 282..312, focus_range: 286..291, name: \"tests\", kind: Module, description: \"mod tests\" })",

"(Test, NavigationTarget { file_id: FileId(0), full_range: 298..307, name: \"foo_test\", kind: Function })",

"(TestMod, NavigationTarget { file_id: FileId(0), full_range: 313..323, name: \"tests2\", kind: Module, description: \"mod tests2\" }, true)",

"#,

expect![[r#"

[

"(Test, NavigationTarget { file_id: FileId(0), full_range: 17..41, focus_range: 32..36, name: \"r#fn\", kind: Function })",

"(DocTest, NavigationTarget { file_id: FileId(0), full_range: 152..266, focus_range: 189..205, name: \"impl\", kind: Impl })",

"(DocTest, NavigationTarget { file_id: FileId(0), full_range: 216..260, name: \"r#fn\" })",

"(DocTest, NavigationTarget { file_id: FileId(0), full_range: 323..367, name: \"r#fn\" })",

false_ = "false",

let_ = "let",

const_ = "const",

proc_dash_macro = "proc-macro",

aapcs_dash_unwind = "aapcs-unwind",

avr_dash_interrupt = "avr-interrupt",