refactor(ide): project semantic targets by intent

Author: hongjr03

crates/ide/src/document_highlight.rs

@@ -33,15 +33,8 @@ 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 target = resolve_semantic_target(
-        db,
-        file_id,
-        offset,
-        parsed_file.root(),
-        TargetIntent::Highlight,
-        token_precedence,
-    );
-    let SemanticTarget::Source(target) = target.for_highlight()? else {
+    let target = resolve_semantic_target(db, file_id, offset, parsed_file.root(), token_precedence);
+    let SemanticTarget::Source(target) = target.for_intent(TargetIntent::Highlight)? else {
         return None;
     };
     let tokens = target.into_tokens();

crates/ide/src/goto_declaration.rs

@@ -22,10 +22,9 @@ pub(crate) fn goto_declaration(
         file_id,
         offset,
         parsed_file.root(),
-        TargetIntent::Navigate,
         goto_definition::token_precedence,
     );
-    let SemanticTarget::Source(target) = target.for_navigation()? else {
+    let SemanticTarget::Source(target) = target.for_intent(TargetIntent::Navigate)? else {
         return None;
     };
     let (range, tokens) = target.into_parts();

crates/ide/src/goto_definition.rs

@@ -30,14 +30,7 @@ pub(crate) fn goto_definition(
 ) -> Option<RangeInfo<Vec<NavTarget>>> {
     let sema = Semantics::new(db);
     let parsed_file = sema.parse_file(file_id);
-    let target = resolve_semantic_target(
-        db,
-        file_id,
-        offset,
-        parsed_file.root(),
-        TargetIntent::Navigate,
-        token_precedence,
-    );
+    let target = resolve_semantic_target(db, file_id, offset, parsed_file.root(), token_precedence);
     render_definition_target(db, file_id, &sema, target)
 }
 
@@ -47,7 +40,7 @@ fn render_definition_target(
     sema: &Semantics<RootDb>,
     target: TargetResolution<'_>,
 ) -> Option<RangeInfo<Vec<NavTarget>>> {
-    match target.for_navigation()? {
+    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) => {

crates/ide/src/hover.rs

@@ -53,14 +53,7 @@ pub(crate) fn hover(
 ) -> Option<RangeInfo<Markup>> {
     let sema = Semantics::new(db);
     let parsed_file = sema.parse_file(file_id);
-    let target = resolve_semantic_target(
-        db,
-        file_id,
-        offset,
-        parsed_file.root(),
-        TargetIntent::Describe,
-        token_precedence,
-    );
+    let target = resolve_semantic_target(db, file_id, offset, parsed_file.root(), token_precedence);
     render_hover_target(db, file_id, offset, &sema, target)
 }
 
@@ -71,7 +64,7 @@ fn render_hover_target(
     sema: &Semantics<RootDb>,
     target: TargetResolution<'_>,
 ) -> Option<RangeInfo<Markup>> {
-    match target.for_hover()? {
+    match target.for_intent(TargetIntent::Describe)? {
         SemanticTarget::PreprocMacro(target) => {
             render_macro_hover_target(db, file_id, offset, target)
         }

crates/ide/src/references.rs

@@ -92,14 +92,7 @@ pub(crate) fn references(
 ) -> Option<Vec<References>> {
     let sema = Semantics::new(db);
     let parsed_file = sema.parse_file(file_id);
-    let target = resolve_semantic_target(
-        db,
-        file_id,
-        offset,
-        parsed_file.root(),
-        TargetIntent::FindReferences,
-        token_precedence,
-    );
+    let target = resolve_semantic_target(db, file_id, offset, parsed_file.root(), token_precedence);
     render_references_target(db, file_id, &sema, target, config)
 }
 
@@ -110,7 +103,7 @@ fn render_references_target(
     target: TargetResolution<'_>,
     config: ReferencesConfig,
 ) -> Option<Vec<References>> {
-    match target.for_references()? {
+    match target.for_intent(TargetIntent::FindReferences)? {
         SemanticTarget::PreprocMacro(target) => {
             render_preproc_references_target(db, file_id, target, &config)
         }

crates/ide/src/rename.rs

@@ -97,33 +97,13 @@ pub struct RenameCollisionInfo {
 
 pub(crate) fn prepare_rename(
     db: &RootDb,
-    FilePosition { file_id, offset }: FilePosition,
+    position @ FilePosition { file_id, .. }: FilePosition,
     config: RenameConfig,
 ) -> RenameResult<TextRange> {
     let sema = Semantics::new(db);
-    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(),
-        TargetIntent::Rename,
-        rename_token_precedence,
-    );
-    let SemanticTarget::Source(target) = target.for_rename().ok_or(RenameError::NoRefFound)? else {
-        return Err(RenameError::NoRefFound);
-    };
-    let token = target.into_tokens().into_iter().next().ok_or(RenameError::NoRefFound)?;
-    let text_range = token.text_range().ok_or(RenameError::NoRefFound)?;
-    let def =
-        match DefinitionClass::resolve(&sema, hir_file_id, token).ok_or(RenameError::NoDefFound)? {
-            DefinitionClass::Definition(def) => def,
-            DefinitionClass::PortConnShorthand { local, .. } => local,
-            DefinitionClass::Ambiguous(_) => return Err(RenameError::NoDefFound),
-        };
-    let _ = config.references_config(db, &def, file_id)?;
-    Ok(text_range)
+    let target = resolve_rename_target(&sema, position)?;
+    let _ = config.references_config(db, &target.selected_def, file_id)?;
+    Ok(target.range)
 }
 
 pub(crate) fn rename(
@@ -221,6 +201,7 @@ pub(crate) fn rename_conflict_info(
 }
 
 struct ResolvedRenameTarget {
+    range: TextRange,
     selected_def: Definition,
     targets: Vec<Definition>,
 }
@@ -237,35 +218,51 @@ fn resolve_rename_target(
     sema: &Semantics<'_, RootDb>,
     FilePosition { file_id, offset }: FilePosition,
 ) -> RenameResult<ResolvedRenameTarget> {
+    let hir_file_id = file_id.into();
     let parsed_file = sema.parse_file(file_id);
     let target = resolve_semantic_target(
         sema.db,
         file_id,
         offset,
         parsed_file.root(),
-        TargetIntent::Rename,
         rename_token_precedence,
     );
-    let SemanticTarget::Source(target) = target.for_rename().ok_or(RenameError::NoRefFound)? else {
+    let SemanticTarget::Source(target) =
+        target.for_intent(TargetIntent::Rename).ok_or(RenameError::NoRefFound)?
+    else {
         return Err(RenameError::NoRefFound);
     };
-    let token = target.into_tokens().into_iter().next().ok_or(RenameError::NoRefFound)?;
+    let (range, tokens) = target.into_parts();
+    let mut selected_def = None;
     let mut targets = UniqVec::<Definition, DefinitionOrigin>::default();
-    let selected_def = match DefinitionClass::resolve(sema, file_id.into(), token)
-        .ok_or(RenameError::NoDefFound)?
-    {
-        DefinitionClass::Definition(def) => {
-            targets.push(def.origins(), def.clone());
-            def
-        }
-        DefinitionClass::PortConnShorthand { port, local } => {
-            targets.push(local.origins(), local.clone());
-            targets.push(port.origins(), port);
-            local
+
+    for token in tokens {
+        let token_selected = match DefinitionClass::resolve(sema, hir_file_id, token)
+            .ok_or(RenameError::NoDefFound)?
+        {
+            DefinitionClass::Definition(def) => {
+                targets.push(def.origins(), def.clone());
+                def
+            }
+            DefinitionClass::PortConnShorthand { port, local } => {
+                targets.push(local.origins(), local.clone());
+                targets.push(port.origins(), port);
+                local
+            }
+            DefinitionClass::Ambiguous(_) => return Err(RenameError::NoDefFound),
+        };
+
+        match &selected_def {
+            Some(selected_def) if selected_def != &token_selected => {
+                return Err(RenameError::NoDefFound);
+            }
+            Some(_) => {}
+            None => selected_def = Some(token_selected),
         }
-        DefinitionClass::Ambiguous(_) => return Err(RenameError::NoDefFound),
-    };
-    Ok(ResolvedRenameTarget { selected_def, targets: targets.into_vec() })
+    }
+
+    let selected_def = selected_def.ok_or(RenameError::NoDefFound)?;
+    Ok(ResolvedRenameTarget { range, selected_def, targets: targets.into_vec() })
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]