whitaker-common 0.2.6

Internal common utilities for Whitaker lints
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Lightweight expression helpers for lint analysis.
#![cfg_attr(test, allow(clippy::expect_used, clippy::unwrap_used))]

use crate::path::SimplePath;

/// A tiny expression model used for helper functions.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Expr {
    /// A call expression with a resolved callee path.
    Call { callee: SimplePath },
    /// A path expression.
    Path(SimplePath),
    /// Any other literal expression (placeholder for expansion).
    Literal(String),
}

/// Returns the callee path of a call expression, if one is present.
///
/// # Examples
///
/// ```
/// use whitaker_common::expr::{Expr, def_id_of_expr_callee};
/// use whitaker_common::path::SimplePath;
///
/// let expr = Expr::Call { callee: SimplePath::from("std::mem::drop") };
/// assert_eq!(
///     def_id_of_expr_callee(&expr).expect("call expression has callee path").segments(),
///     &["std", "mem", "drop"]
/// );
/// ```
#[must_use]
pub fn def_id_of_expr_callee(expr: &Expr) -> Option<&SimplePath> {
    match expr {
        Expr::Call { callee } => Some(callee),
        _ => None,
    }
}

/// Tests whether a path matches the provided candidate segments.
///
/// # Examples
///
/// ```
/// use whitaker_common::expr::is_path_to;
/// use whitaker_common::path::SimplePath;
///
/// let path = SimplePath::from("core::option::Option");
/// assert!(is_path_to(&path, ["core", "option", "Option"]));
/// ```
#[must_use]
pub fn is_path_to<'a, I>(path: &SimplePath, candidate: I) -> bool
where
    I: IntoIterator<Item = &'a str>,
{
    path.matches(candidate)
}

/// Returns `true` when the receiver is `Option` or `Result` regardless of module
/// path.
///
/// # Examples
///
/// ```
/// use whitaker_common::expr::recv_is_option_or_result;
/// use whitaker_common::path::SimplePath;
///
/// assert!(recv_is_option_or_result(&SimplePath::from("std::option::Option")));
/// assert!(recv_is_option_or_result(&SimplePath::from("Result")));
/// assert!(!recv_is_option_or_result(&SimplePath::from("crate::Thing")));
/// ```
#[must_use]
pub fn recv_is_option_or_result(path: &SimplePath) -> bool {
    matches!(path.last(), Some("Option" | "Result"))
}

#[cfg(test)]
mod tests {
    use super::*;
    use rstest::rstest;

    #[rstest]
    fn callee_extraction() {
        let expr = Expr::Call {
            callee: SimplePath::from("std::mem::drop"),
        };
        assert!(def_id_of_expr_callee(&expr).is_some());
    }

    #[rstest]
    fn recognizes_option_like_receivers() {
        let option_path = SimplePath::from("std::option::Option");
        let result_path = SimplePath::from("Result");
        let custom_path = SimplePath::from("crate::Thing");

        assert!(recv_is_option_or_result(&option_path));
        assert!(recv_is_option_or_result(&result_path));
        assert!(!recv_is_option_or_result(&custom_path));
    }
}