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
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// Language-specific name resolvers
// Included by cross_language_dependencies.rs — no `use` imports allowed

/// Java-to-Kotlin name resolver
pub struct JavaKotlinResolver;

impl NameResolver for JavaKotlinResolver {
    fn can_resolve(
        &self,
        source_language: Language,
        target_language: Language,
        _source: &UnifiedNode,
        reference: &crate::ast::polyglot::unified_node::NodeReference,
        target: &UnifiedNode,
    ) -> bool {
        // Only handle Java->Kotlin and Kotlin->Java
        if !((source_language == Language::Java && target_language == Language::Kotlin)
            || (source_language == Language::Kotlin && target_language == Language::Java))
        {
            return false;
        }

        // Direct name match
        if reference.target_name == target.name {
            return true;
        }

        // FQN match
        if reference.target_name == target.fqn {
            return true;
        }

        // Java package name conversion (com.example -> com.example)
        let src_parts: Vec<&str> = reference.target_name.split('.').collect();
        let tgt_parts: Vec<&str> = target.fqn.split('.').collect();

        if src_parts.len() == tgt_parts.len() {
            // Check if all parts except the last match exactly
            if src_parts[0..src_parts.len() - 1] == tgt_parts[0..tgt_parts.len() - 1] {
                // Check if the last part (class/method name) matches
                if src_parts.last().expect("internal error")
                    == tgt_parts.last().expect("internal error")
                {
                    return true;
                }
            }
        }

        false
    }
}

/// Java-to-Scala name resolver
pub struct JavaScalaResolver;

impl NameResolver for JavaScalaResolver {
    fn can_resolve(
        &self,
        source_language: Language,
        target_language: Language,
        _source: &UnifiedNode,
        reference: &crate::ast::polyglot::unified_node::NodeReference,
        target: &UnifiedNode,
    ) -> bool {
        // Only handle Java->Scala and Scala->Java
        if !((source_language == Language::Java && target_language == Language::Scala)
            || (source_language == Language::Scala && target_language == Language::Java))
        {
            return false;
        }

        // Direct name match
        if reference.target_name == target.name {
            return true;
        }

        // FQN match
        if reference.target_name == target.fqn {
            return true;
        }

        // Scala package name conversion (com.example -> com.example)
        let src_parts: Vec<&str> = reference.target_name.split('.').collect();
        let tgt_parts: Vec<&str> = target.fqn.split('.').collect();

        if src_parts.len() == tgt_parts.len() {
            // Check if all parts except the last match exactly
            if src_parts[0..src_parts.len() - 1] == tgt_parts[0..tgt_parts.len() - 1] {
                // Check if the last part (class/method name) matches
                if src_parts.last().expect("internal error")
                    == tgt_parts.last().expect("internal error")
                {
                    return true;
                }
            }
        }

        false
    }
}

/// TypeScript-to-Java name resolver
pub struct TypeScriptJavaResolver;

impl NameResolver for TypeScriptJavaResolver {
    fn can_resolve(
        &self,
        source_language: Language,
        target_language: Language,
        _source: &UnifiedNode,
        reference: &crate::ast::polyglot::unified_node::NodeReference,
        target: &UnifiedNode,
    ) -> bool {
        // Only handle TypeScript->Java and Java->TypeScript
        if !((source_language == Language::TypeScript && target_language == Language::Java)
            || (source_language == Language::Java && target_language == Language::TypeScript))
        {
            return false;
        }

        // Direct name match
        if reference.target_name == target.name {
            return true;
        }

        // Handle common naming conventions in web applications
        // e.g., UserService.ts might reference com.example.UserService
        if target.fqn.ends_with(&reference.target_name) {
            return true;
        }

        // Handle TypeScript interface to Java class mapping (IUser -> User)
        if source_language == Language::TypeScript
            && reference.target_name.starts_with('I')
            && reference.target_name.len() > 1
        {
            let name_without_i = reference.target_name.get(1..).unwrap_or_default();
            if name_without_i == target.name {
                return true;
            }
            if target.fqn.ends_with(name_without_i) {
                return true;
            }
        }

        false
    }
}