pmat 3.11.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Helper functions for working with AstItem enum in MCP integration
//!
//! This module provides utility functions to extract information from AstItem
//! enum variants, avoiding direct field access which doesn't work on enums.
//!
//! ## Module Organization
//! - Main file: imports, extraction functions, type predicates
//! - `ast_item_helpers_tests.rs`: comprehensive unit tests

use crate::services::context::AstItem;

/// Extract the name from an AstItem
pub fn extract_name(item: &AstItem) -> String {
    match item {
        AstItem::Function { name, .. } => name.clone(),
        AstItem::Struct { name, .. } => name.clone(),
        AstItem::Enum { name, .. } => name.clone(),
        AstItem::Trait { name, .. } => name.clone(),
        AstItem::Impl { type_name, .. } => type_name.clone(),
        AstItem::Use { path, .. } => path.clone(),
        AstItem::Module { name, .. } => name.clone(),
        AstItem::Import { module, .. } => module.clone(),
    }
}

/// Extract the kind/type as a string from an AstItem
pub fn extract_kind(item: &AstItem) -> String {
    match item {
        AstItem::Function { .. } => "function".to_string(),
        AstItem::Struct { .. } => "struct".to_string(),
        AstItem::Enum { .. } => "enum".to_string(),
        AstItem::Trait { .. } => "trait".to_string(),
        AstItem::Impl { .. } => "impl".to_string(),
        AstItem::Use { .. } => "use".to_string(),
        AstItem::Module { .. } => "module".to_string(),
        AstItem::Import { .. } => "import".to_string(),
    }
}

/// Extract the visibility from an AstItem
pub fn extract_visibility(item: &AstItem) -> String {
    match item {
        AstItem::Function { visibility, .. } => visibility.clone(),
        AstItem::Struct { visibility, .. } => visibility.clone(),
        AstItem::Enum { visibility, .. } => visibility.clone(),
        AstItem::Trait { visibility, .. } => visibility.clone(),
        AstItem::Module { visibility, .. } => visibility.clone(),
        AstItem::Impl { .. } => "public".to_string(),
        AstItem::Use { .. } => "public".to_string(),
        AstItem::Import { .. } => "public".to_string(),
    }
}

/// Extract the line number from an AstItem
pub fn extract_line(item: &AstItem) -> usize {
    match item {
        AstItem::Function { line, .. } => *line,
        AstItem::Struct { line, .. } => *line,
        AstItem::Enum { line, .. } => *line,
        AstItem::Trait { line, .. } => *line,
        AstItem::Impl { line, .. } => *line,
        AstItem::Use { line, .. } => *line,
        AstItem::Module { line, .. } => *line,
        AstItem::Import { line, .. } => *line,
    }
}

/// Calculate a simple complexity score for an AstItem
/// This is a basic heuristic; real complexity should come from analysis
pub fn extract_complexity(item: &AstItem) -> u32 {
    match item {
        AstItem::Function { .. } => 5,
        AstItem::Impl { .. } => 3,
        AstItem::Struct { .. } => 2,
        AstItem::Enum { .. } => 2,
        AstItem::Trait { .. } => 2,
        AstItem::Module { .. } => 1,
        AstItem::Use { .. } => 1,
        AstItem::Import { .. } => 1,
    }
}

/// Extract all common information from an AstItem as a tuple
/// Returns: (name, kind, visibility, line, complexity)
pub fn extract_all_info(item: &AstItem) -> (String, String, String, usize, u32) {
    (
        extract_name(item),
        extract_kind(item),
        extract_visibility(item),
        extract_line(item),
        extract_complexity(item),
    )
}

/// Check if an AstItem is a function
pub fn is_function(item: &AstItem) -> bool {
    matches!(item, AstItem::Function { .. })
}

/// Check if an AstItem is a struct
pub fn is_struct(item: &AstItem) -> bool {
    matches!(item, AstItem::Struct { .. })
}

/// Check if an AstItem is an enum
pub fn is_enum(item: &AstItem) -> bool {
    matches!(item, AstItem::Enum { .. })
}

/// Check if an AstItem is a trait
pub fn is_trait(item: &AstItem) -> bool {
    matches!(item, AstItem::Trait { .. })
}

/// Check if an AstItem is an impl block
pub fn is_impl(item: &AstItem) -> bool {
    matches!(item, AstItem::Impl { .. })
}

/// Check if an AstItem is a module
pub fn is_module(item: &AstItem) -> bool {
    matches!(item, AstItem::Module { .. })
}

/// Check if an AstItem is async (only applicable to functions)
pub fn is_async(item: &AstItem) -> bool {
    match item {
        AstItem::Function { is_async, .. } => *is_async,
        _ => false,
    }
}

// --- Tests (included from separate file) ---
include!("ast_item_helpers_tests.rs");