Skip to main content

code_transpiler/
registry.rs

1#[derive(Debug, Clone, PartialEq, Eq)]
2pub struct FrontendSpec {
3    pub id: &'static str,
4    pub aliases: &'static [&'static str],
5    pub extensions: &'static [&'static str],
6    pub capabilities: &'static [&'static str],
7}
8#[derive(Debug, Clone, PartialEq, Eq)]
9pub struct BackendSpec {
10    pub id: &'static str,
11    pub aliases: &'static [&'static str],
12    pub capabilities: &'static [&'static str],
13}
14
15const FRONTENDS: &[FrontendSpec] = &[
16    FrontendSpec {
17        id: "r",
18        aliases: &["r"],
19        extensions: &[".r", ".R"],
20        capabilities: &[
21            "core",
22            "lazy_evaluation",
23            "named_arguments",
24            "one_based_index",
25        ],
26    },
27    FrontendSpec {
28        id: "go",
29        aliases: &["go"],
30        extensions: &[".go"],
31        capabilities: &["core", "eager_evaluation"],
32    },
33    FrontendSpec {
34        id: "python",
35        aliases: &["python", "py"],
36        extensions: &[".py"],
37        capabilities: &["core", "eager_evaluation", "named_arguments"],
38    },
39    FrontendSpec {
40        id: "rust",
41        aliases: &["rust", "rs"],
42        extensions: &[".rs"],
43        capabilities: &["core", "eager_evaluation"],
44    },
45    FrontendSpec {
46        id: "c",
47        aliases: &["c"],
48        extensions: &[".c", ".h"],
49        capabilities: &["core", "eager_evaluation"],
50    },
51    FrontendSpec {
52        id: "cpp",
53        aliases: &["cpp", "c++"],
54        extensions: &[".cpp", ".cc", ".cxx", ".hpp"],
55        capabilities: &["core", "eager_evaluation"],
56    },
57    FrontendSpec {
58        id: "zig",
59        aliases: &["zig"],
60        extensions: &[".zig"],
61        capabilities: &["core", "eager_evaluation"],
62    },
63    FrontendSpec {
64        id: "julia",
65        aliases: &["julia", "jl"],
66        extensions: &[".jl"],
67        capabilities: &["core", "eager_evaluation"],
68    },
69    FrontendSpec {
70        id: "se",
71        aliases: &["se", "semantic", "semantic-exchange"],
72        extensions: &[".se"],
73        capabilities: &["core", "semantic_exchange"],
74    },
75    FrontendSpec {
76        id: "nim",
77        aliases: &["nim"],
78        extensions: &[".nim"],
79        capabilities: &["core", "eager_evaluation"],
80    },
81    FrontendSpec {
82        id: "csharp",
83        aliases: &["csharp", "c#", "cs"],
84        extensions: &[".cs"],
85        capabilities: &["core", "eager_evaluation"],
86    },
87    FrontendSpec {
88        id: "java",
89        aliases: &["java"],
90        extensions: &[".java"],
91        capabilities: &["core", "eager_evaluation"],
92    },
93    FrontendSpec {
94        id: "kotlin",
95        aliases: &["kotlin", "kt"],
96        extensions: &[".kt", ".kts"],
97        capabilities: &["core", "eager_evaluation"],
98    },
99    FrontendSpec {
100        id: "swift",
101        aliases: &["swift"],
102        extensions: &[".swift"],
103        capabilities: &["core", "eager_evaluation"],
104    },
105];
106
107const BACKENDS: &[BackendSpec] = &[
108    BackendSpec {
109        id: "r",
110        aliases: &["r"],
111        capabilities: &["core"],
112    },
113    BackendSpec {
114        id: "go",
115        aliases: &["go"],
116        capabilities: &["core"],
117    },
118    BackendSpec {
119        id: "python",
120        aliases: &["python", "py"],
121        capabilities: &["core"],
122    },
123    BackendSpec {
124        id: "rust",
125        aliases: &["rust", "rs"],
126        capabilities: &["core"],
127    },
128    BackendSpec {
129        id: "c",
130        aliases: &["c"],
131        capabilities: &["core"],
132    },
133    BackendSpec {
134        id: "cpp",
135        aliases: &["cpp", "c++"],
136        capabilities: &["core"],
137    },
138    BackendSpec {
139        id: "zig",
140        aliases: &["zig"],
141        capabilities: &["core"],
142    },
143    BackendSpec {
144        id: "julia",
145        aliases: &["julia", "jl"],
146        capabilities: &["core"],
147    },
148    BackendSpec {
149        id: "se",
150        aliases: &["se", "semantic", "semantic-exchange"],
151        capabilities: &["core", "semantic_exchange"],
152    },
153    BackendSpec {
154        id: "nim",
155        aliases: &["nim"],
156        capabilities: &["core"],
157    },
158    BackendSpec {
159        id: "csharp",
160        aliases: &["csharp", "c#", "cs"],
161        capabilities: &["core"],
162    },
163    BackendSpec {
164        id: "java",
165        aliases: &["java"],
166        capabilities: &["core"],
167    },
168    BackendSpec {
169        id: "kotlin",
170        aliases: &["kotlin", "kt"],
171        capabilities: &["core"],
172    },
173    BackendSpec {
174        id: "swift",
175        aliases: &["swift"],
176        capabilities: &["core"],
177    },
178];
179
180pub fn frontends() -> &'static [FrontendSpec] {
181    FRONTENDS
182}
183pub fn backends() -> &'static [BackendSpec] {
184    BACKENDS
185}
186pub fn normalize_language(name: &str) -> String {
187    let n = name.trim().to_ascii_lowercase();
188    FRONTENDS
189        .iter()
190        .find(|s| s.aliases.iter().any(|a| *a == n))
191        .map(|s| s.id.to_string())
192        .unwrap_or(n)
193}
194pub fn has_frontend(name: &str) -> bool {
195    let n = normalize_language(name);
196    FRONTENDS.iter().any(|s| s.id == n)
197}
198pub fn has_backend(name: &str) -> bool {
199    let n = normalize_language(name);
200    BACKENDS.iter().any(|s| s.id == n)
201}
202
203#[derive(Debug, Clone, Copy, PartialEq, Eq)]
204pub enum CapabilityStatus {
205    Native,
206    Lowering,
207    Emulated,
208    Unsupported,
209}
210#[derive(Debug, Clone, PartialEq, Eq)]
211pub struct CapabilityResult {
212    pub feature: String,
213    pub backend: String,
214    pub status: CapabilityStatus,
215    pub reason: String,
216}
217
218pub fn backend_capability(feature: &str, backend: &str) -> CapabilityResult {
219    let b = normalize_language(backend);
220    if !has_backend(&b) {
221        return CapabilityResult {
222            feature: feature.into(),
223            backend: b,
224            status: CapabilityStatus::Unsupported,
225            reason: "unknown backend".into(),
226        };
227    }
228    let integer = feature.starts_with("integer.")
229        || feature.starts_with("native.integer.")
230        || feature.starts_with("fixed_width_integer.");
231    if integer && ["go", "python", "c", "rust", "cpp", "java", "csharp"].contains(&b.as_str()) {
232        return CapabilityResult {
233            feature: feature.into(),
234            backend: b,
235            status: CapabilityStatus::Lowering,
236            reason: "fixed-width integer operations with explicit wrap semantics".into(),
237        };
238    }
239    if feature == "core" {
240        return CapabilityResult {
241            feature: feature.into(),
242            backend: b,
243            status: CapabilityStatus::Lowering,
244            reason: "shared semantic core lowering".into(),
245        };
246    }
247    CapabilityResult {
248        feature: feature.into(),
249        backend: b,
250        status: CapabilityStatus::Unsupported,
251        reason: "backend has no declared capability".into(),
252    }
253}