refactor(ide): centralize semantic target resolution

crates/ide/src/document_highlight.rs

@@ -11,6 +11,7 @@ use crate::{
         self, ReferenceCategory, ReferencesConfig,
         search::{ReferencesCtx, SearchScope},
     },
+    semantic_target::{SemanticTarget, TargetIntent, resolve_semantic_target},
 };
 
 #[derive(Debug, Clone)]
@@ -32,16 +33,11 @@ pub(crate) fn document_highlight(
     let sema = Semantics::new(db);
     let hir_file_id = file_id.into();
     let parsed_file = sema.parse_file(file_id);
-    let root = parsed_file.root()?;
-    let tokens = crate::source_targets::source_target_at_offset(
-        db,
-        file_id,
-        root,
-        offset,
-        token_precedence,
-    )?
-    .resolved()?
-    .into_tokens();
+    let target = resolve_semantic_target(db, file_id, offset, parsed_file.root(), token_precedence);
+    let SemanticTarget::Source(target) = target.unique_for_intent(TargetIntent::Highlight)? else {
+        return None;
+    };
+    let tokens = target.into_tokens();
     let highlights = tokens
         .into_iter()
         .filter_map(|token| highlight_for_token(&sema, file_id, hir_file_id, token, config.clone()))

crates/ide/src/goto_declaration.rs

@@ -1,12 +1,15 @@
-use hir::semantics::Semantics;
+use hir::{file::HirFileId, semantics::Semantics};
 use itertools::Itertools;
+use utils::line_index::covering_range;
 
 use crate::{
     FilePosition, RangeInfo,
     db::root_db::RootDb,
     definitions::DefinitionClass,
     goto_definition,
     navigation_target::{NavTarget, ToNav},
+    semantic_target::{SemanticTarget, TargetIntent, resolve_semantic_target},
+    source_targets::SourceTarget,
 };
 
 pub(crate) fn goto_declaration(
@@ -16,20 +19,53 @@ pub(crate) fn goto_declaration(
     let sema = Semantics::new(db);
     let hir_file_id = file_id.into();
     let parsed_file = sema.parse_file(file_id);
-    let root = parsed_file.root()?;
-    let target = crate::source_targets::source_target_at_offset(
+    let target = resolve_semantic_target(
         db,
         file_id,
-        root,
         offset,
+        parsed_file.root(),
         goto_definition::token_precedence,
-    )?
-    .resolved()?;
+    );
+    render_declaration_target(
+        db,
+        hir_file_id,
+        &sema,
+        target.targets_for_intent(TargetIntent::Navigate),
+    )
+}
+
+fn render_declaration_target(
+    db: &RootDb,
+    hir_file_id: HirFileId,
+    sema: &Semantics<RootDb>,
+    targets: Vec<SemanticTarget<'_>>,
+) -> Option<RangeInfo<Vec<NavTarget>>> {
+    let mut ranges = Vec::new();
+    let mut navs = Vec::new();
+    for target in targets {
+        let SemanticTarget::Source(target) = target else {
+            return None;
+        };
+        let target = render_source_declaration_target(db, hir_file_id, sema, target)?;
+        ranges.push(target.range);
+        navs.extend(target.info);
+    }
+
+    let range = covering_range(&ranges)?;
+    Some(RangeInfo::new(range, navs.into_iter().unique().collect()))
+}
+
+fn render_source_declaration_target(
+    db: &RootDb,
+    hir_file_id: HirFileId,
+    sema: &Semantics<RootDb>,
+    target: SourceTarget<'_>,
+) -> Option<RangeInfo<Vec<NavTarget>>> {
     let (range, tokens) = target.into_parts();
 
     let origins = tokens
         .into_iter()
-        .filter_map(|token| match DefinitionClass::resolve(&sema, hir_file_id, token)? {
+        .filter_map(|token| match DefinitionClass::resolve(sema, hir_file_id, token)? {
             DefinitionClass::Definition(definition) => {
                 Some(definition.declaration_origins().into_iter().collect_vec())
             }

crates/ide/src/goto_definition.rs

@@ -2,84 +2,64 @@ use hir::{
     base_db::source_db::SourceDb,
     container::InFile,
     file::HirFileId,
-    preproc::{
-        IncludeDirective, IncludeTarget, MacroDefinition, MacroParamDefinition,
-        MacroParamReferenceDefinitions, MacroReferenceDefinitions, include_directives_at,
-        macro_definition_at, macro_param_definition_at, macro_param_reference_definitions_at,
-        macro_reference_definitions_at,
-    },
+    preproc::{IncludeDirective, IncludeTarget, MacroDefinition, MacroParamDefinition},
     semantics::Semantics,
 };
 use itertools::Itertools;
 use syntax::{
-    SyntaxNode, SyntaxTokenWithParent, TokenKind,
+    SyntaxTokenWithParent, TokenKind,
     token::{TokenKindExt, pair_token},
 };
-use utils::line_index::{TextRange, TextSize};
+use utils::line_index::{TextRange, TextSize, covering_range};
 use vfs::FileId;
 
 use crate::{
     FilePosition, RangeInfo,
     db::root_db::RootDb,
     definitions::DefinitionClass,
     navigation_target::{NavTarget, ToNav},
-    source_targets::{SourceTarget, source_target_at_offset},
+    semantic_target::{
+        PreprocMacroTarget, SemanticTarget, TargetIntent, TargetResolution, resolve_semantic_target,
+    },
+    source_targets::SourceTarget,
 };
 
-enum DefinitionTarget<'tree> {
-    Preproc(Box<PreprocDefinitionTarget>),
-    Include(Vec<IncludeDirective>),
-    Source(SourceTarget<'tree>),
-}
-
-enum PreprocDefinitionTarget {
-    ParamDefinition(MacroParamDefinition),
-    ParamReference(MacroParamReferenceDefinitions),
-    Definition(MacroDefinition),
-    Reference(MacroReferenceDefinitions),
-}
-
 pub(crate) fn goto_definition(
     db: &RootDb,
     FilePosition { file_id, offset }: FilePosition,
 ) -> Option<RangeInfo<Vec<NavTarget>>> {
     let sema = Semantics::new(db);
     let parsed_file = sema.parse_file(file_id);
-    let target = dispatch_definition_target(db, file_id, offset, parsed_file.root())?;
+    let target = resolve_semantic_target(db, file_id, offset, parsed_file.root(), token_precedence);
     render_definition_target(db, file_id, &sema, target)
 }
 
-fn dispatch_definition_target<'tree>(
-    db: &RootDb,
-    file_id: FileId,
-    offset: TextSize,
-    root: Option<SyntaxNode<'tree>>,
-) -> Option<DefinitionTarget<'tree>> {
-    if let Some(target) = dispatch_preproc_definition_target(db, file_id, offset) {
-        return Some(DefinitionTarget::Preproc(Box::new(target)));
-    }
-    if let Some(includes) = dispatch_include_definition_target(db, file_id, offset) {
-        return Some(DefinitionTarget::Include(includes));
-    }
-    let root = root?;
-    let target =
-        source_target_at_offset(db, file_id, root, offset, token_precedence)?.resolved()?;
-    Some(DefinitionTarget::Source(target))
-}
-
 fn render_definition_target(
     db: &RootDb,
     file_id: FileId,
     sema: &Semantics<RootDb>,
-    target: DefinitionTarget<'_>,
+    target: TargetResolution<'_>,
 ) -> Option<RangeInfo<Vec<NavTarget>>> {
-    match target {
-        DefinitionTarget::Preproc(target) => render_preproc_definition_target(*target),
-        DefinitionTarget::Include(includes) => render_include_definition_target(db, includes),
-        DefinitionTarget::Source(target) => {
-            render_source_definition_target(db, file_id, sema, target)
-        }
+    let mut ranges = Vec::new();
+    let mut navs = Vec::new();
+    for target in target.targets_for_intent(TargetIntent::Navigate) {
+        let target = match target {
+            SemanticTarget::PreprocMacro(target) => render_preproc_definition_target(target),
+            SemanticTarget::Include(includes) => render_include_definition_target(db, includes),
+            SemanticTarget::Source(target) => {
+                render_source_definition_target(db, file_id, sema, target)
+            }
+        }?;
+        ranges.push(target.range);
+        navs.extend(target.info);
+    }
+
+    if navs.is_empty() {
+        return None;
     }
+
+    let range = covering_range(&ranges)?;
+    Some(RangeInfo::new(range, navs.into_iter().unique().collect()))
 }
 
 fn render_source_definition_target(
@@ -120,47 +100,23 @@ fn nav_targets_for_token(
     })
 }
 
-fn dispatch_preproc_definition_target(
-    db: &RootDb,
-    file_id: FileId,
-    offset: TextSize,
-) -> Option<PreprocDefinitionTarget> {
-    if let Ok(Some(definition)) = macro_param_definition_at(db, file_id, offset) {
-        return Some(PreprocDefinitionTarget::ParamDefinition(definition));
-    }
-
-    if let Ok(Some(resolution)) = macro_param_reference_definitions_at(db, file_id, offset) {
-        return Some(PreprocDefinitionTarget::ParamReference(resolution));
-    }
-
-    if let Ok(Some(definition)) = macro_definition_at(db, file_id, offset) {
-        return Some(PreprocDefinitionTarget::Definition(definition));
-    }
-
-    if let Ok(Some(resolution)) = macro_reference_definitions_at(db, file_id, offset) {
-        return Some(PreprocDefinitionTarget::Reference(resolution));
-    }
-
-    None
-}
-
 fn render_preproc_definition_target(
-    target: PreprocDefinitionTarget,
+    target: PreprocMacroTarget,
 ) -> Option<RangeInfo<Vec<NavTarget>>> {
     match target {
-        PreprocDefinitionTarget::ParamDefinition(definition) => {
+        PreprocMacroTarget::ParamDefinition(definition) => {
             Some(RangeInfo::new(definition.range, vec![macro_param_nav_target(definition)]))
         }
-        PreprocDefinitionTarget::ParamReference(resolution) => {
+        PreprocMacroTarget::ParamReference(resolution) => {
             let reference_range = resolution.range;
             let targets =
                 resolution.definitions.into_iter().map(macro_param_nav_target).collect_vec();
             (!targets.is_empty()).then_some(RangeInfo::new(reference_range, targets))
         }
-        PreprocDefinitionTarget::Definition(definition) => {
+        PreprocMacroTarget::Definition(definition) => {
             Some(RangeInfo::new(definition.name_range, vec![macro_nav_target(definition)]))
         }
-        PreprocDefinitionTarget::Reference(resolution) => {
+        PreprocMacroTarget::Reference(resolution) => {
             let reference_range = resolution.range;
             let targets = resolution.definitions.into_iter().map(macro_nav_target).collect_vec();
             (!targets.is_empty()).then_some(RangeInfo::new(reference_range, targets))
@@ -192,15 +148,6 @@ fn macro_nav_target(definition: MacroDefinition) -> NavTarget {
     }
 }
 
-fn dispatch_include_definition_target(
-    db: &RootDb,
-    file_id: FileId,
-    offset: TextSize,
-) -> Option<Vec<IncludeDirective>> {
-    let includes = include_directives_at(db, file_id, offset).ok()?;
-    (!includes.is_empty()).then_some(includes)
-}
-
 fn render_include_definition_target(
     db: &RootDb,
     includes: Vec<IncludeDirective>,