refactor(ide): model semantic target alternatives

Author: hongjr03

crates/ide/src/document_highlight.rs

@@ -34,7 +34,7 @@ pub(crate) fn document_highlight(
     let hir_file_id = file_id.into();
     let parsed_file = sema.parse_file(file_id);
     let target = resolve_semantic_target(db, file_id, offset, parsed_file.root(), token_precedence);
-    let SemanticTarget::Source(target) = target.for_intent(TargetIntent::Highlight)? else {
+    let SemanticTarget::Source(target) = target.unique_for_intent(TargetIntent::Highlight)? else {
         return None;
     };
     let tokens = target.into_tokens();

crates/ide/src/goto_declaration.rs

@@ -24,7 +24,7 @@ pub(crate) fn goto_declaration(
         parsed_file.root(),
         goto_definition::token_precedence,
     );
-    let SemanticTarget::Source(target) = target.for_intent(TargetIntent::Navigate)? else {
+    let SemanticTarget::Source(target) = target.unique_for_intent(TargetIntent::Navigate)? else {
         return None;
     };
     let (range, tokens) = target.into_parts();

crates/ide/src/goto_definition.rs

@@ -40,13 +40,32 @@ fn render_definition_target(
     sema: &Semantics<RootDb>,
     target: TargetResolution<'_>,
 ) -> Option<RangeInfo<Vec<NavTarget>>> {
-    match target.for_intent(TargetIntent::Navigate)? {
-        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)
-        }
+    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 covering_range(ranges: &[TextRange]) -> Option<TextRange> {
+    let start = ranges.iter().map(|range| range.start()).min()?;
+    let end = ranges.iter().map(|range| range.end()).max()?;
+    Some(TextRange::new(start, end))
 }
 
 fn render_source_definition_target(

crates/ide/src/hover.rs

@@ -64,16 +64,38 @@ fn render_hover_target(
     sema: &Semantics<RootDb>,
     target: TargetResolution<'_>,
 ) -> Option<RangeInfo<Markup>> {
-    match target.for_intent(TargetIntent::Describe)? {
-        SemanticTarget::PreprocMacro(target) => {
-            render_macro_hover_target(db, file_id, offset, target)
-        }
-        SemanticTarget::Include(includes) => render_include_hover(db, includes),
-        SemanticTarget::Source(target) => {
-            let hover = hover_for_source_target(sema, file_id.into(), target)?;
-            Some(with_expanded_macro_hover(db, file_id, offset, hover))
-        }
+    let mut ranges = Vec::new();
+    let mut markups = Vec::new();
+    let mut has_source_target = false;
+
+    for target in target.targets_for_intent(TargetIntent::Describe) {
+        let hover = match target {
+            SemanticTarget::PreprocMacro(target) => {
+                render_macro_hover_target(db, file_id, offset, target)
+            }
+            SemanticTarget::Include(includes) => render_include_hover(db, includes),
+            SemanticTarget::Source(target) => {
+                has_source_target = true;
+                hover_for_source_target(sema, file_id.into(), target)
+            }
+        }?;
+        ranges.push(hover.range);
+        markups.push(hover.info);
     }
+
+    let range = covering_range(&ranges)?;
+    let hover = RangeInfo::new(range, merge_hover_results(markups)?);
+    Some(if has_source_target {
+        with_expanded_macro_hover(db, file_id, offset, hover)
+    } else {
+        hover
+    })
+}
+
+fn covering_range(ranges: &[TextRange]) -> Option<TextRange> {
+    let start = ranges.iter().map(|range| range.start()).min()?;
+    let end = ranges.iter().map(|range| range.end()).max()?;
+    Some(TextRange::new(start, end))
 }
 
 fn hover_for_source_target(

crates/ide/src/references.rs

@@ -103,7 +103,7 @@ fn render_references_target(
     target: TargetResolution<'_>,
     config: ReferencesConfig,
 ) -> Option<Vec<References>> {
-    match target.for_intent(TargetIntent::FindReferences)? {
+    match target.unique_for_intent(TargetIntent::FindReferences)? {
         SemanticTarget::PreprocMacro(target) => {
             render_preproc_references_target(db, file_id, target, &config)
         }

crates/ide/src/rename.rs

@@ -228,7 +228,7 @@ fn resolve_rename_target(
         rename_token_precedence,
     );
     let SemanticTarget::Source(target) =
-        target.for_intent(TargetIntent::Rename).ok_or(RenameError::NoRefFound)?
+        target.unique_for_intent(TargetIntent::Rename).ok_or(RenameError::NoRefFound)?
     else {
         return Err(RenameError::NoRefFound);
     };

crates/ide/src/semantic_target.rs

@@ -11,8 +11,9 @@ use vfs::FileId;
 use crate::{
     db::root_db::RootDb,
     source_targets::{
-        SourceTarget, SourceTargetBlock, SourceTargetBlockReason, SourceTargetDomain,
-        SourceTargetResolution, source_target_at_offset,
+        SourceTarget, SourceTargetAlternatives, SourceTargetAmbiguity, SourceTargetBlock,
+        SourceTargetBlockReason, SourceTargetDomain, SourceTargetResolution,
+        source_target_at_offset,
     },
 };
 
@@ -51,30 +52,30 @@ bitflags::bitflags! {
 #[derive(Debug, Clone)]
 pub(crate) enum TargetResolution<'tree> {
     Resolved(TargetCandidate<'tree>),
-    Ambiguous(TargetAmbiguity),
+    Ambiguous(TargetAlternatives<'tree>),
     Blocked(TargetBlock),
     Unresolved,
 }
 
 impl<'tree> TargetResolution<'tree> {
-    pub(crate) fn for_intent(self, intent: TargetIntent) -> Option<SemanticTarget<'tree>> {
-        self.into_primary(intent.capability())
+    pub(crate) fn unique_for_intent(self, intent: TargetIntent) -> Option<SemanticTarget<'tree>> {
+        let mut targets = self.targets_for_intent(intent);
+        (targets.len() == 1).then(|| targets.pop().expect("single target should exist"))
     }
 
-    fn into_primary(self, required: TargetCapability) -> Option<SemanticTarget<'tree>> {
+    pub(crate) fn targets_for_intent(self, intent: TargetIntent) -> Vec<SemanticTarget<'tree>> {
+        let required = intent.capability();
         match self {
-            TargetResolution::Resolved(candidate) => candidate.into_target(required),
-            TargetResolution::Ambiguous(ambiguity) => {
-                let TargetAmbiguity { anchor, reason } = ambiguity;
-                let _ = (anchor, reason);
-                None
+            TargetResolution::Resolved(candidate) => {
+                candidate.into_target(required).into_iter().collect()
             }
+            TargetResolution::Ambiguous(alternatives) => alternatives.into_targets(required),
             TargetResolution::Blocked(block) => {
                 let TargetBlock { anchor, reason } = block;
                 let _ = (anchor, reason);
-                None
+                Vec::new()
             }
-            TargetResolution::Unresolved => None,
+            TargetResolution::Unresolved => Vec::new(),
         }
     }
 
@@ -87,6 +88,9 @@ impl<'tree> TargetResolution<'tree> {
                 let capabilities = source_capabilities();
                 Self::Resolved(TargetCandidate::new(SemanticTarget::Source(target), capabilities))
             }
+            SourceTargetResolution::Ambiguous(alternatives) => {
+                Self::from_source_alternatives(file_id, alternatives)
+            }
             SourceTargetResolution::Blocked(block) => {
                 let SourceTargetBlock { range, .. } = block.clone();
                 let anchor = TargetAnchor {
@@ -99,6 +103,22 @@ impl<'tree> TargetResolution<'tree> {
         }
     }
 
+    fn from_source_alternatives(
+        file_id: FileId,
+        alternatives: SourceTargetAlternatives<'tree>,
+    ) -> Self {
+        let SourceTargetAlternatives { domain, range, reason, targets } = alternatives;
+        let anchor =
+            TargetAnchor { file_id, range, origin: TargetOrigin::from_source_domain(domain) };
+        let reason = TargetAmbiguityReason::from_source(reason);
+        let capabilities = source_capabilities();
+        let candidates = targets
+            .into_iter()
+            .map(|target| TargetCandidate::new(SemanticTarget::Source(target), capabilities))
+            .collect();
+        Self::Ambiguous(TargetAlternatives { anchor, reason, candidates })
+    }
+
     fn from_preproc_macro(target: PreprocMacroTarget) -> Self {
         let capabilities = target.capabilities();
         Self::Resolved(TargetCandidate::new(SemanticTarget::PreprocMacro(target), capabilities))
@@ -118,9 +138,10 @@ impl<'tree> TargetResolution<'tree> {
                 Self::Blocked(TargetBlock { anchor, reason: TargetBlockReason::PreprocUnavailable })
             }
             (SourceTargetDomain::Preproc, SourceTargetBlockReason::Ambiguous { hits }) => {
-                Self::Ambiguous(TargetAmbiguity {
+                Self::Ambiguous(TargetAlternatives {
                     anchor,
-                    reason: TargetAmbiguityReason::PreprocHits { candidate_count: hits.len() },
+                    reason: TargetAmbiguityReason::PreprocHits { hit_count: hits.len() },
+                    candidates: Vec::new(),
                 })
             }
         }
@@ -140,11 +161,15 @@ pub(crate) enum TargetOrigin {
 }
 
 impl TargetOrigin {
-    fn from_source_block(block: &SourceTargetBlock) -> Self {
-        match block.domain {
+    fn from_source_domain(domain: SourceTargetDomain) -> Self {
+        match domain {
             SourceTargetDomain::Preproc => TargetOrigin::MacroExpansion,
         }
     }
+
+    fn from_source_block(block: &SourceTargetBlock) -> Self {
+        Self::from_source_domain(block.domain)
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -168,14 +193,33 @@ impl<'tree> TargetCandidate<'tree> {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct TargetAmbiguity {
+pub(crate) struct TargetAlternatives<'tree> {
     pub anchor: TargetAnchor,
     pub reason: TargetAmbiguityReason,
+    pub candidates: Vec<TargetCandidate<'tree>>,
+}
+
+impl<'tree> TargetAlternatives<'tree> {
+    fn into_targets(self, required: TargetCapability) -> Vec<SemanticTarget<'tree>> {
+        let Self { anchor, reason, candidates } = self;
+        let _ = (anchor, reason);
+        candidates.into_iter().filter_map(|candidate| candidate.into_target(required)).collect()
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum TargetAmbiguityReason {
-    PreprocHits { candidate_count: usize },
+    PreprocHits { hit_count: usize },
+}
+
+impl TargetAmbiguityReason {
+    fn from_source(reason: SourceTargetAmbiguity) -> Self {
+        match reason {
+            SourceTargetAmbiguity::PreprocHits { hit_count } => {
+                TargetAmbiguityReason::PreprocHits { hit_count }
+            }
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -345,11 +389,11 @@ mod tests {
         let resolution =
             resolve_semantic_target(host.raw_db(), file_id, offset, Some(root), token_precedence);
         assert!(matches!(
-            resolution.clone().for_intent(TargetIntent::Describe),
+            resolution.clone().unique_for_intent(TargetIntent::Describe),
             Some(SemanticTarget::Source(_))
         ));
         assert!(matches!(
-            resolution.clone().for_intent(TargetIntent::Rename),
+            resolution.clone().unique_for_intent(TargetIntent::Rename),
             Some(SemanticTarget::Source(_))
         ));
 
@@ -403,6 +447,39 @@ mod tests {
             panic!("conflicting source target should be ambiguous");
         };
 
-        assert_eq!(ambiguity.reason, TargetAmbiguityReason::PreprocHits { candidate_count: 0 });
+        assert_eq!(ambiguity.reason, TargetAmbiguityReason::PreprocHits { hit_count: 0 });
+        assert!(ambiguity.candidates.is_empty());
+    }
+
+    #[test]
+    fn ambiguous_source_target_alternatives_project_as_candidates() {
+        let range = TextRange::new(TextSize::from(1), TextSize::from(4));
+        let target_range = TextRange::new(TextSize::from(2), TextSize::from(3));
+        let target = crate::source_targets::SourceTarget {
+            origin: crate::source_targets::SourceTargetOrigin::NormalSyntax,
+            range: target_range,
+            tokens: Vec::new(),
+        };
+        let alternatives = crate::source_targets::SourceTargetAlternatives {
+            domain: crate::source_targets::SourceTargetDomain::Preproc,
+            range,
+            reason: crate::source_targets::SourceTargetAmbiguity::PreprocHits { hit_count: 2 },
+            targets: vec![target.clone(), target],
+        };
+
+        let resolution = TargetResolution::from_source_resolution(
+            FileId(0),
+            crate::source_targets::SourceTargetResolution::Ambiguous(alternatives),
+        );
+
+        assert!(resolution.clone().unique_for_intent(TargetIntent::Describe).is_none());
+        assert_eq!(resolution.clone().targets_for_intent(TargetIntent::Describe).len(), 2);
+
+        let TargetResolution::Ambiguous(alternatives) = resolution else {
+            panic!("source alternatives should stay ambiguous");
+        };
+        assert_eq!(alternatives.anchor.range, range);
+        assert_eq!(alternatives.reason, TargetAmbiguityReason::PreprocHits { hit_count: 2 });
+        assert_eq!(alternatives.candidates.len(), 2);
     }
 }