refactor(const_path_join): improve handling of constant expressions in path construction

Enhance the logic for suggesting path construction methods based on the number of constant expressions. Introduce checks to differentiate between single and multiple constants, updating suggestions accordingly. This change improves the accuracy of linting messages for path joins.

Author: jesicaMao

examples/restriction/const_path_join/src/lib.rs

@@ -80,6 +80,13 @@ impl<'tcx> LateLintPass<'tcx> for ConstPathJoin {
         let all_const_or_literal = components
             .iter()
             .all(|c| !matches!(c, ComponentType::Other));
+            
+        // Only consider constants if there are multiple constants
+        // If there's just one constant with string literals, treat as normal joins
+        let has_multiple_constants = components
+            .iter()
+            .filter(|c| matches!(c, ComponentType::Constant(_)))
+            .count() > 1;
 
         if all_literals {
             // Suggest joining into a single string literal
@@ -111,8 +118,8 @@ impl<'tcx> LateLintPass<'tcx> for ConstPathJoin {
                 sugg,
                 Applicability::MachineApplicable,
             );
-        } else if all_const_or_literal {
-            // Suggest using concat!()
+        } else if all_const_or_literal && has_multiple_constants {
+            // Suggest using concat!() only when there are multiple constant expressions
             let concat_args = components
                 .iter()
                 .enumerate()
@@ -132,20 +139,57 @@ impl<'tcx> LateLintPass<'tcx> for ConstPathJoin {
                 .collect::<Vec<String>>()
                 .join(", ");
 
-            let sugg = format!("concat!({concat_args})");
-            
-            let span = match ty_or_partial_span {
-                TyOrPartialSpan::Ty(_) => expr.span,
-                // For partial joins, we need a wider span
-                TyOrPartialSpan::PartialSpan(partial_span) => expr.span.with_lo(partial_span.lo()), 
+            let (span, sugg) = match ty_or_partial_span {
+                TyOrPartialSpan::Ty(ty) => (
+                    expr.span,
+                    format!(r#"{}::from(concat!({concat_args}))"#, ty.join("::"))
+                ),
+                TyOrPartialSpan::PartialSpan(partial_span) => {
+                    // We need to replace the entire chain of joins with a single join of the concat
+                    let full_span = expr.span.with_lo(partial_span.lo());
+                    (full_span, format!(r#".join(concat!({concat_args}))"#))
+                }
             };
 
             span_lint_and_sugg(
                 cx,
                 CONST_PATH_JOIN,
                 span, 
+                "path could be constructed with concat!",
+                "consider using",
+                sugg,
+                Applicability::MachineApplicable,
+            );
+        } else if all_const_or_literal {
+            // For a single constant expression with string literals, treat like string literals
+            let joined_path = components
+                .iter()
+                .map(|c| match c {
+                    ComponentType::Literal(s) => s.as_str(),
+                    ComponentType::Constant(_) => "..", // We know it's a path component
+                    _ => unreachable!(), // Already checked all are const or literals
+                })
+                .collect::<Vec<&str>>()
+                .join("/");
+            
+            let (span, sugg) = match ty_or_partial_span {
+                TyOrPartialSpan::Ty(ty) => (
+                    expr.span,
+                    format!(r#"{}::from("{joined_path}")"#, ty.join("::"))
+                ),
+                TyOrPartialSpan::PartialSpan(partial_span) => {
+                    // Use a wider span to replace all the joins
+                    let full_span = expr.span.with_lo(partial_span.lo());
+                    (full_span, format!(r#".join("{joined_path}")"#))
+                }
+            };
+            
+            span_lint_and_sugg(
+                cx,
+                CONST_PATH_JOIN,
+                span,
                 "path could be constructed from a string literal",
-                "consider using concat!",
+                "use",
                 sugg,
                 Applicability::MachineApplicable,
             );
@@ -242,18 +286,26 @@ fn check_component_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) ->
         return ComponentType::Literal(s);
     }
 
+    // Check if it's a concat!() or env!() macro
+    if let ExprKind::Call(callee, _) = expr.kind {
+        if is_expr_path_def_path(cx, callee, &["std", "concat"]) || 
+           is_expr_path_def_path(cx, callee, &["std", "env"]) {
+            if let Some(snippet) = snippet_opt(cx, expr.span) {
+                return ComponentType::Constant(snippet);
+            }
+        }
+    }
+
     // Check if it's a constant-evaluatable string expression
     if !expr.span.from_expansion()
         && is_const_evaluatable(cx, expr)
         && matches!(cx.typeck_results().expr_ty(expr).kind(), ty::Str)
     {
         if let Some(snippet) = snippet_opt(cx, expr.span) {
-            // Consider it a constant component if we can get the snippet
             return ComponentType::Constant(snippet);
         }
     }
 
-    // Otherwise, it's neither a literal nor a recognized constant string
     ComponentType::Other
 }