refactor: centralize path-anchor handling in import path resolution

- Added `PathAnchor` helpers in `src/rust_syntax.rs` to classify leading path segments (`crate`, `super`, `self`, `Self`, names) and removed scattered string-comparison dispatch from path rewriting and resolution paths.
- Replaced repeated inline `crate`/`super`/`self` handling in compiler and fix modules with `PathAnchor`-driven logic to keep leading-segment interpretation aligned across `src/fixes` and `src/compiler`.
- Rewrote two two-arm `match` expressions into combinator form in `src/fixes/runner/apply.rs` and `src/selection/metadata.rs` to use `map_or`/`map_or_else`.

Author: natepiano

src/compiler/facade/exports.rs

@@ -18,6 +18,7 @@ use crate::compiler::settings::DriverSettings;
 use crate::compiler::source_cache;
 use crate::compiler::source_cache::SourceCache;
 use crate::rust_syntax;
+use crate::rust_syntax::PathAnchor;
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub enum ParentFacadeFixSupport {
@@ -184,11 +185,7 @@ fn parent_boundary_has_matching_pub_use_glob(file: &File, child_module_name: &st
         let mut paths = Vec::new();
         source_cache::flatten_use_tree(Vec::new(), &item_use.tree, &mut paths);
         paths.into_iter().any(|path| {
-            let normalized = if path.first().is_some_and(|segment| segment == "self") {
-                &path[1..]
-            } else {
-                &path[..]
-            };
+            let normalized = rust_syntax::trim_leading_self(&path);
             normalized.len() == 2 && normalized[0] == child_module_name && normalized[1] == "*"
         })
     })
@@ -231,11 +228,7 @@ fn collect_matching_pub_use_exports(
     source_cache::flatten_use_tree(Vec::new(), &item_use.tree, &mut paths);
     let mut matched = false;
     for path in paths {
-        let normalized = if path.first().is_some_and(|segment| segment == "self") {
-            &path[1..]
-        } else {
-            &path[..]
-        };
+        let normalized = rust_syntax::trim_leading_self(&path);
         if normalized.len() >= 2
             && normalized[0] == child_module_name
             && normalized[1..].iter().any(|segment| segment == item_name)
@@ -283,11 +276,7 @@ fn pub_use_is_fix_supported_with_prefix(
             pub_use_is_fix_supported_with_prefix(next, &path.tree, child_module_name, item_name)
         },
         UseTree::Name(name) => {
-            let normalized = if prefix.first().is_some_and(|segment| segment == "self") {
-                &prefix[1..]
-            } else {
-                &prefix[..]
-            };
+            let normalized = rust_syntax::trim_leading_self(&prefix);
             normalized.len() == 1 && normalized[0] == child_module_name && name.ident == item_name
         },
         UseTree::Group(group) => group.items.iter().any(|item| {
@@ -300,17 +289,14 @@ fn pub_use_is_fix_supported_with_prefix(
 pub(super) fn parent_facade_visibility(vis: &Visibility) -> Option<ParentFacadeVisibility> {
     match vis {
         Visibility::Public(_) => Some(ParentFacadeVisibility::Public),
-        Visibility::Restricted(restricted)
-            if restricted.path.segments.len() == 1
-                && restricted.path.segments[0].ident == "super" =>
-        {
-            Some(ParentFacadeVisibility::Super)
-        },
-        Visibility::Restricted(restricted)
-            if restricted.path.segments.len() == 1
-                && restricted.path.segments[0].ident == "crate" =>
-        {
-            Some(ParentFacadeVisibility::Crate)
+        Visibility::Restricted(restricted) if restricted.path.segments.len() == 1 => {
+            let path_anchor =
+                PathAnchor::from(restricted.path.segments[0].ident.to_string().as_str());
+            match path_anchor {
+                PathAnchor::Super => Some(ParentFacadeVisibility::Super),
+                PathAnchor::Crate => Some(ParentFacadeVisibility::Crate),
+                PathAnchor::SelfMod | PathAnchor::SelfType | PathAnchor::Name => None,
+            }
         },
         _ => None,
     }

src/compiler/facade/reference.rs

@@ -13,6 +13,7 @@ use crate::compiler::source_cache::ExtractedPaths;
 use crate::compiler::source_cache::PathOrigin;
 use crate::compiler::source_cache::SourceCache;
 use crate::compiler::source_cache::UseRename;
+use crate::rust_syntax::PathAnchor;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ParentFacadeUsage {
@@ -241,30 +242,38 @@ pub(super) fn resolve_module_relative_paths(
         return Vec::new();
     }
 
-    if raw.first().map(String::as_str) == Some("crate") {
-        return vec![raw[1..].to_vec()];
-    }
-
-    if raw.first().map(String::as_str) == Some("self") {
-        let mut resolved = current_module_path.to_vec();
-        resolved.extend(raw[1..].iter().cloned());
-        return vec![resolved];
-    }
-
-    if raw.first().map(String::as_str) == Some("super") {
-        let mut index = 0usize;
-        let mut resolved = current_module_path.to_vec();
-        while raw.get(index).is_some_and(|segment| segment == "super") {
-            if resolved.pop().is_none() {
-                return Vec::new();
+    let Some(path_anchor) = PathAnchor::first(raw) else {
+        return Vec::new();
+    };
+    match path_anchor {
+        PathAnchor::Crate => return vec![raw[1..].to_vec()],
+        PathAnchor::SelfMod => {
+            let mut resolved = current_module_path.to_vec();
+            resolved.extend(raw[1..].iter().cloned());
+            return vec![resolved];
+        },
+        PathAnchor::Super => {
+            let mut index = 0usize;
+            let mut resolved = current_module_path.to_vec();
+            while raw
+                .get(index)
+                .is_some_and(|segment| PathAnchor::from(segment.as_str()) == PathAnchor::Super)
+            {
+                if resolved.pop().is_none() {
+                    return Vec::new();
+                }
+                index += 1;
             }
-            index += 1;
-        }
-        if raw.get(index).is_some_and(|segment| segment == "self") {
-            index += 1;
-        }
-        resolved.extend(raw[index..].iter().cloned());
-        return vec![resolved];
+            if raw
+                .get(index)
+                .is_some_and(|segment| PathAnchor::from(segment.as_str()) == PathAnchor::SelfMod)
+            {
+                index += 1;
+            }
+            resolved.extend(raw[index..].iter().cloned());
+            return vec![resolved];
+        },
+        PathAnchor::SelfType | PathAnchor::Name => {},
     }
 
     (0..=current_module_path.len())
@@ -458,20 +467,20 @@ fn relative_tail_mentions_child_item(
     child_module_path: &[String],
     item_name: &str,
 ) -> bool {
-    if path.first().map(String::as_str) == Some("crate") || child_module_path.is_empty() {
+    if PathAnchor::first(path) == Some(PathAnchor::Crate) || child_module_path.is_empty() {
         return false;
     }
 
     let mut tail_start = 0usize;
     while path
         .get(tail_start)
-        .is_some_and(|segment| segment == "super")
+        .is_some_and(|segment| PathAnchor::from(segment.as_str()) == PathAnchor::Super)
     {
         tail_start += 1;
     }
     if path
         .get(tail_start)
-        .is_some_and(|segment| segment == "self")
+        .is_some_and(|segment| PathAnchor::from(segment.as_str()) == PathAnchor::SelfMod)
     {
         tail_start += 1;
     }

src/compiler/source_cache.rs

@@ -18,6 +18,7 @@ use super::constants::SOURCE_DIR_BENCHES;
 use super::constants::SOURCE_DIR_EXAMPLES;
 use super::constants::SOURCE_DIR_SRC;
 use super::constants::SOURCE_DIR_TESTS;
+use crate::rust_syntax::PathAnchor;
 use crate::selection::CARGO_TARGET_KIND_LIB;
 use crate::selection::CARGO_TARGET_KIND_MAIN;
 
@@ -233,10 +234,10 @@ fn collect_rust_source_files(dir: &Path, files: &mut Vec<PathBuf>) -> Result<()>
 }
 
 pub(super) fn path_origin(raw: &[String]) -> PathOrigin {
-    if raw.first().map(String::as_str) == Some("crate") {
-        PathOrigin::Crate
-    } else {
-        PathOrigin::Relative
+    match PathAnchor::first(raw) {
+        Some(PathAnchor::Crate) => PathOrigin::Crate,
+        Some(PathAnchor::Super | PathAnchor::SelfMod | PathAnchor::SelfType | PathAnchor::Name)
+        | None => PathOrigin::Relative,
     }
 }
 

src/compiler/visibility/use_sites.rs

@@ -43,6 +43,7 @@ use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::Visibility;
 
 use crate::compiler::persistence::UseSite;
+use crate::rust_syntax::PathAnchor;
 
 /// Walk the entire crate's HIR and append every resolved
 /// expression/type/pattern path reference to `out`. The caller module is
@@ -399,7 +400,7 @@ pub(super) fn parent_module_path_segments(tcx: TyCtxt<'_>, def_id: LocalDefId) -
         .filter(|segment| !segment.is_empty())
         .map(String::from)
         .collect::<Vec<_>>();
-    if segments.first().is_some_and(|segment| segment == "crate") {
+    if PathAnchor::first(&segments) == Some(PathAnchor::Crate) {
         segments.remove(0);
     }
     segments

src/fixes/imports/path.rs

@@ -2,6 +2,8 @@ use proc_macro2::LineColumn;
 use syn::UseTree;
 
 use crate::config::DiagnosticCode;
+use crate::rust_syntax;
+use crate::rust_syntax::PathAnchor;
 
 pub(super) struct ImportCandidate {
     pub(super) original:        String,
@@ -15,8 +17,11 @@ pub(super) fn analyze_use_tree(
     tree: &UseTree,
 ) -> Option<ImportCandidate> {
     let import = flatten_use_tree(tree)?;
-    if import.segments.first()? != "crate" {
-        return None;
+    match PathAnchor::first(&import.segments)? {
+        PathAnchor::Crate => {},
+        PathAnchor::Super | PathAnchor::SelfMod | PathAnchor::SelfType | PathAnchor::Name => {
+            return None;
+        },
     }
 
     let target_segments = &import.segments[1..];
@@ -54,7 +59,7 @@ pub(super) fn analyze_deep_super(
     tree: &UseTree,
 ) -> Option<ImportCandidate> {
     let import = flatten_use_tree(tree)?;
-    let super_count = import.segments.iter().take_while(|s| *s == "super").count();
+    let super_count = rust_syntax::leading_super_count(&import.segments);
     if super_count < 2 {
         return None;
     }

src/fixes/inline_path_qualified_type/process.rs

@@ -12,6 +12,7 @@ use crate::fixes::imports::UseFix;
 use crate::reporting::Finding;
 use crate::reporting::FixSupport;
 use crate::reporting::Severity;
+use crate::rust_syntax::PathAnchor;
 
 pub(super) struct OccurrenceContext<'a> {
     pub(super) path:            &'a Path,
@@ -168,8 +169,11 @@ fn absolutize_import_path(import_path: &str, existing_imports: &BTreeSet<String>
     let Some((leading, rest)) = import_path.split_once("::") else {
         return import_path.to_string();
     };
-    if leading == "crate" || leading == "super" || leading == "self" {
-        return import_path.to_string();
+    match PathAnchor::from(leading) {
+        PathAnchor::Crate | PathAnchor::Super | PathAnchor::SelfMod => {
+            return import_path.to_string();
+        },
+        PathAnchor::SelfType | PathAnchor::Name => {},
     }
     // Look for an existing `use a::b::<leading>;` (i.e. an import whose final
     // segment matches `leading` and which has at least one parent segment).

src/fixes/inline_path_qualified_type/scope.rs

@@ -7,6 +7,7 @@ use syn::spanned::Spanned;
 
 use super::offsets;
 use super::visitor;
+use crate::rust_syntax::PathAnchor;
 
 pub(super) struct ScopeInfo {
     pub(super) span_start:              usize,
@@ -142,7 +143,7 @@ pub(super) fn canonicalize_inserted_use_path(scope: &ScopeInfo, full_path: &str)
     let segments: Vec<&str> = full_path.split("::").collect();
     let super_count = segments
         .iter()
-        .take_while(|segment| **segment == "super")
+        .take_while(|segment| PathAnchor::from(**segment) == PathAnchor::Super)
         .count();
     if super_count < 2 || super_count > scope.module_path.len() {
         return full_path.to_string();

src/fixes/inline_path_qualified_type/visitor.rs

@@ -25,6 +25,8 @@ use syn::UseTree;
 use syn::visit;
 use syn::visit::Visit;
 
+use crate::rust_syntax::PathAnchor;
+
 pub(super) struct InlinePathOccurrence {
     /// The original fully-qualified path as written (e.g.
     /// `crate::project::RustProject::Package`).
@@ -81,7 +83,8 @@ impl InlinePathVisitor {
         }
 
         let first = &segments[0];
-        let is_intra_crate = first == "crate" || first == "super";
+        let path_anchor = PathAnchor::from(first.as_str());
+        let is_intra_crate = path_anchor.is_crate_relative();
 
         // For intra-crate paths, require at least 3 segments: `crate::Foo` and
         // `super::Foo` are already short, so adding a `use` would not shorten
@@ -93,7 +96,7 @@ impl InlinePathVisitor {
 
         // Filter obvious non-crate roots. `self::` is a same-module reference,
         // not a candidate for a `use`.
-        if first == "self" || first == "Self" {
+        if path_anchor.is_explicit_self() {
             return;
         }
 

src/fixes/prefer_module_import/function_imports.rs

@@ -9,6 +9,7 @@ use syn::visit::Visit;
 use syn::visit::visit_item_mod;
 
 use super::support;
+use crate::rust_syntax::PathAnchor;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(super) enum ImportTarget {
@@ -71,8 +72,8 @@ fn analyze_function_import(
         return None;
     }
 
-    let first = flat.segments.first()?;
-    if first != "crate" && first != "super" {
+    let path_anchor = PathAnchor::first(&flat.segments)?;
+    if !path_anchor.is_crate_relative() {
         return None;
     }
 
@@ -92,7 +93,7 @@ fn analyze_function_import(
 
     let module_segments = &flat.segments[..flat.segments.len() - 1];
     let module_name = flat.segments[flat.segments.len() - 2].clone();
-    if module_name == "super" || module_name == "crate" {
+    if PathAnchor::from(module_name.as_str()).is_crate_relative() {
         return None;
     }
     if !support::is_snake_case_module_name(&module_name) {
@@ -104,10 +105,11 @@ fn analyze_function_import(
 
     let shortened_module_segments =
         support::shorten_module_path(current_module_path, module_segments);
-    let import_target = if shortened_module_segments.as_slice() == ["super"] {
-        ImportTarget::ParentModule
-    } else {
-        ImportTarget::OtherModule
+    let import_target = match shortened_module_segments.as_slice() {
+        [segment] if PathAnchor::from(segment.as_str()) == PathAnchor::Super => {
+            ImportTarget::ParentModule
+        },
+        _ => ImportTarget::OtherModule,
     };
     let module_path = shortened_module_segments.join("::");
     let replacement_use = if import_target == ImportTarget::ParentModule {

src/fixes/prefer_module_import/inline_calls.rs

@@ -19,6 +19,7 @@ use crate::fixes::imports::UseFix;
 use crate::reporting::Finding;
 use crate::reporting::FixSupport;
 use crate::reporting::Severity;
+use crate::rust_syntax::PathAnchor;
 
 pub(super) struct InlineCallCandidate {
     pub(super) function_name:   String,
@@ -196,8 +197,8 @@ fn analyze_inline_call(
         return None;
     }
 
-    let first = segments.first()?;
-    if first != "crate" && first != "super" {
+    let path_anchor = PathAnchor::first(&segments)?;
+    if !path_anchor.is_crate_relative() {
         return None;
     }
 
@@ -220,7 +221,7 @@ fn analyze_inline_call(
     }
 
     let module_name = segments[segments.len() - 2].clone();
-    if module_name == "super" || module_name == "crate" {
+    if PathAnchor::from(module_name.as_str()).is_crate_relative() {
         return None;
     }
     if !support::is_snake_case_module_name(&module_name) {
@@ -232,10 +233,11 @@ fn analyze_inline_call(
 
     let module_segments = &segments[..segments.len() - 1];
     let shortened = support::shorten_module_path(current_module_path, module_segments);
-    let import_target = if shortened.as_slice() == ["super"] {
-        ImportTarget::ParentModule
-    } else {
-        ImportTarget::OtherModule
+    let import_target = match shortened.as_slice() {
+        [segment] if PathAnchor::from(segment.as_str()) == PathAnchor::Super => {
+            ImportTarget::ParentModule
+        },
+        _ => ImportTarget::OtherModule,
     };
     let module_path = shortened.join("::");