1mod call_resolution;
9mod capability_matrix;
10mod emit;
11mod exact;
12mod go_ir;
13mod gui;
14mod ir;
15mod julia_ir;
16mod matrix;
17mod native_abi;
18mod native_go;
19mod python_frontend;
20mod registry;
21mod runtime;
22mod semantic;
23mod semantic_exchange;
24mod signature;
25mod target;
26mod type_conversion;
27
28pub use call_resolution::{
29 validate_call_resolution, CallCandidate, CallResolution, EXACT_CALL_RESOLUTION_CAPABILITY,
30};
31pub use capability_matrix::{semantic_capability_matrix, CapabilityMatrix};
32pub use exact::{exact_value, r_exact, ExactError, ExactValue, RExact};
33pub use go_ir::{parse_expr as parse_go_expr, parse_go, GoParseError};
34pub use gui::{gui, serve_gui, GuiHandle};
35pub use ir::{Expr, Function, Param, Program, Stmt, Type};
36pub use julia_ir::{parse_julia, parse_julia_expr, JuliaParseError};
37pub use matrix::{Matrix, SparseMatrix};
38pub use native_abi::{
39 decide_native_storage, native_windows_x64_target_profile, solve_native_layout,
40 NativeAbiContext, NativeLayout, NativeRepresentation, NativeStorageDecision,
41 NativeStorageRequest, NativeTargetProfile, NativeValue, NativeValueTag,
42};
43pub use native_go::{native_go_to_rust, native_go_to_target, NativeTranspileError};
44pub use python_frontend::{parse_python, python_to_julia_pivot, PythonParseError};
45pub use registry::{
46 backend_capability, backends, frontends, has_backend, has_frontend, normalize_language,
47 BackendSpec, CapabilityResult, CapabilityStatus, FrontendSpec,
48};
49pub use runtime::{r_bind, r_call, RValue, RuntimeError};
50pub use semantic::{
51 missing_structured_fields, snapshot_iteration, structured_input_fields, summarize_effect_axes,
52 SemanticEffectSummary, StructuredConstructInput,
53};
54pub use semantic_exchange::{
55 semantic_exchange, semantic_exchange_pivot, semantic_json, semantic_program, semantic_text,
56 SemanticBindingInfo, SemanticFunctionInfo, SemanticOperationInfo, SemanticProgram, SE_MAGIC,
57};
58pub use signature::{
59 bind_signature, validate_signature_contract, FunctionSignatureContract, SignatureArgument,
60 SignatureBinding, SignatureParameter, EXACT_SIGNATURE_CAPABILITY,
61};
62pub use target::{
63 emit_dispatch, target_inf, target_na, target_name, PreservationMode, PreservationRegistry,
64 PreservationRule, Requirement, RequirementKind, RequirementRegistry,
65};
66pub use type_conversion::{
67 resolve_universal_type_conversion, universal_type_conversion_registry, LoweringExactness,
68 TypeConversionRecipe, TypeConversionStatus,
69};
70
71use std::fs;
72use std::io;
73use std::path::{Path, PathBuf};
74use std::process::Command;
75
76#[derive(Debug, Clone, PartialEq, Eq)]
77pub struct Language {
78 pub id: &'static str,
79 pub name: &'static str,
80 pub extensions: &'static [&'static str],
81 pub aliases: &'static [&'static str],
82}
83
84const LANGUAGES: &[Language] = &[
85 Language {
86 id: "r",
87 name: "R",
88 extensions: &[".R", ".r"],
89 aliases: &[],
90 },
91 Language {
92 id: "go",
93 name: "Go",
94 extensions: &[".go"],
95 aliases: &[],
96 },
97 Language {
98 id: "rust",
99 name: "Rust",
100 extensions: &[".rs"],
101 aliases: &["rs"],
102 },
103 Language {
104 id: "cpp",
105 name: "C++",
106 extensions: &[".cpp", ".cc", ".cxx"],
107 aliases: &["c++"],
108 },
109 Language {
110 id: "c",
111 name: "C",
112 extensions: &[".c", ".h"],
113 aliases: &[],
114 },
115 Language {
116 id: "python",
117 name: "Python",
118 extensions: &[".py"],
119 aliases: &["py"],
120 },
121 Language {
122 id: "zig",
123 name: "Zig",
124 extensions: &[".zig"],
125 aliases: &[],
126 },
127 Language {
128 id: "julia",
129 name: "Julia",
130 extensions: &[".jl"],
131 aliases: &["jl"],
132 },
133 Language {
134 id: "se",
135 name: "Semantic Exchange",
136 extensions: &[".se"],
137 aliases: &["semantic", "semantic-exchange"],
138 },
139 Language {
140 id: "nim",
141 name: "Nim",
142 extensions: &[".nim"],
143 aliases: &[],
144 },
145 Language {
146 id: "csharp",
147 name: "C#",
148 extensions: &[".cs"],
149 aliases: &["c#", "cs"],
150 },
151 Language {
152 id: "java",
153 name: "Java",
154 extensions: &[".java"],
155 aliases: &[],
156 },
157 Language {
158 id: "kotlin",
159 name: "Kotlin",
160 extensions: &[".kt", ".kts"],
161 aliases: &["kt"],
162 },
163 Language {
164 id: "swift",
165 name: "Swift",
166 extensions: &[".swift"],
167 aliases: &[],
168 },
169];
170
171const NATIVE_TARGETS_FROM_GO: &[&str] = &["rust", "python", "julia", "c", "cpp", "se"];
172const NATIVE_TARGETS_FROM_JULIA: &[&str] = &["rust", "python", "c", "cpp", "se"];
173const NATIVE_TARGETS_FROM_PYTHON: &[&str] = &["rust", "julia", "c", "cpp", "se"];
174const NATIVE_TARGETS_FROM_SE: &[&str] = &["rust", "python", "julia", "c", "cpp"];
175
176pub fn languages() -> &'static [Language] {
177 LANGUAGES
178}
179
180pub fn routes() -> Vec<(&'static str, &'static str)> {
182 let mut out = Vec::new();
183 out.extend(NATIVE_TARGETS_FROM_GO.iter().map(|t| ("go", *t)));
184 out.extend(NATIVE_TARGETS_FROM_JULIA.iter().map(|t| ("julia", *t)));
185 out.extend(NATIVE_TARGETS_FROM_PYTHON.iter().map(|t| ("python", *t)));
186 out.extend(NATIVE_TARGETS_FROM_SE.iter().map(|t| ("se", *t)));
187 out
188}
189
190pub fn targets_for_source(source: &str) -> Vec<&'static str> {
191 match canonical_language(source) {
192 Ok("go") => NATIVE_TARGETS_FROM_GO.to_vec(),
193 Ok("julia") => NATIVE_TARGETS_FROM_JULIA.to_vec(),
194 Ok("python") => NATIVE_TARGETS_FROM_PYTHON.to_vec(),
195 Ok("se") => NATIVE_TARGETS_FROM_SE.to_vec(),
196 _ => Vec::new(),
197 }
198}
199
200pub fn source_languages() -> Vec<&'static Language> {
201 LANGUAGES.iter().collect()
202}
203pub fn route_supported(source: &str, target: &str) -> bool {
204 match (canonical_language(source), canonical_language(target)) {
205 (Ok(a), Ok(b)) if a == b => true,
206 (Ok("go"), Ok(b)) => NATIVE_TARGETS_FROM_GO.contains(&b),
207 (Ok("julia"), Ok(b)) => NATIVE_TARGETS_FROM_JULIA.contains(&b),
208 (Ok("python"), Ok(b)) => NATIVE_TARGETS_FROM_PYTHON.contains(&b),
209 (Ok("se"), Ok(b)) => NATIVE_TARGETS_FROM_SE.contains(&b),
210 _ => false,
211 }
212}
213
214#[derive(Debug)]
215pub enum TranspileError {
216 UnsupportedLanguage(String),
217 UnsupportedRoute { source: String, target: String },
218 Native(String),
219 Io(io::Error),
220}
221impl std::fmt::Display for TranspileError {
222 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
223 match self {
224 Self::UnsupportedLanguage(x) => write!(f, "unsupported language: {x}"),
225 Self::UnsupportedRoute { source, target } => {
226 write!(f, "native route not implemented: {source} -> {target}")
227 }
228 Self::Native(x) => write!(f, "native transpilation failed: {x}"),
229 Self::Io(e) => write!(f, "I/O error: {e}"),
230 }
231 }
232}
233impl std::error::Error for TranspileError {}
234impl From<io::Error> for TranspileError {
235 fn from(value: io::Error) -> Self {
236 Self::Io(value)
237 }
238}
239
240fn canonical_language(id: &str) -> Result<&'static str, TranspileError> {
241 let needle = id.trim().to_ascii_lowercase();
242 for lang in LANGUAGES {
243 if needle == lang.id || lang.aliases.iter().any(|a| needle == *a) {
244 return Ok(lang.id);
245 }
246 }
247 Err(TranspileError::UnsupportedLanguage(id.to_string()))
248}
249
250pub fn backend_status() -> (&'static str, bool) {
251 ("native-rust", true)
252}
253
254pub fn transpile(source: &str, target: &str, code: &str) -> Result<String, TranspileError> {
255 let src = canonical_language(source)?;
256 let dst = canonical_language(target)?;
257 if src == dst {
258 return Ok(code.to_string());
259 }
260 if src == "go" && NATIVE_TARGETS_FROM_GO.contains(&dst) {
261 if dst == "se" {
262 let program = parse_go(code).map_err(|e| TranspileError::Native(e.to_string()))?;
263 return semantic_exchange("go", &program).map_err(TranspileError::Native);
264 }
265 return native_go_to_target(code, dst).map_err(|e| TranspileError::Native(e.to_string()));
266 }
267 if src == "julia" && NATIVE_TARGETS_FROM_JULIA.contains(&dst) {
268 let program = parse_julia(code).map_err(|e| TranspileError::Native(e.to_string()))?;
269 if dst == "se" {
270 return semantic_exchange("julia", &program).map_err(TranspileError::Native);
271 }
272 return crate::emit::emit(&program, dst).map_err(|e| TranspileError::Native(e.to_string()));
273 }
274 if src == "python" && NATIVE_TARGETS_FROM_PYTHON.contains(&dst) {
275 let program = parse_python(code).map_err(|e| TranspileError::Native(e.to_string()))?;
276 if dst == "se" {
277 return semantic_exchange("python", &program).map_err(TranspileError::Native);
278 }
279 return crate::emit::emit(&program, dst).map_err(|e| TranspileError::Native(e.to_string()));
280 }
281 if src == "se" && NATIVE_TARGETS_FROM_SE.contains(&dst) {
282 let pivot = semantic_exchange_pivot(code).map_err(TranspileError::Native)?;
283 if dst == "julia" {
284 return Ok(pivot);
285 }
286 let program = parse_julia(&pivot).map_err(|e| TranspileError::Native(e.to_string()))?;
287 return crate::emit::emit(&program, dst).map_err(|e| TranspileError::Native(e.to_string()));
288 }
289 Err(TranspileError::UnsupportedRoute {
290 source: src.to_string(),
291 target: dst.to_string(),
292 })
293}
294
295pub fn transpile_file(
296 input: impl AsRef<Path>,
297 output: impl AsRef<Path>,
298 source: Option<&str>,
299 target: &str,
300) -> Result<PathBuf, TranspileError> {
301 let input = input.as_ref();
302 let src_owned;
303 let src = if let Some(s) = source {
304 s
305 } else {
306 src_owned = language_from_path(input)?.to_string();
307 &src_owned
308 };
309 let generated = transpile(src, target, &fs::read_to_string(input)?)?;
310 if let Some(parent) = output.as_ref().parent() {
311 fs::create_dir_all(parent)?;
312 }
313 fs::write(output.as_ref(), generated)?;
314 Ok(output.as_ref().to_path_buf())
315}
316
317fn language_from_path(path: &Path) -> Result<&'static str, TranspileError> {
318 let name = path.to_string_lossy().to_ascii_lowercase();
319 for lang in LANGUAGES {
320 for ext in lang.extensions {
321 if name.ends_with(&ext.to_ascii_lowercase()) {
322 return Ok(lang.id);
323 }
324 }
325 }
326 Err(TranspileError::UnsupportedLanguage(name))
327}
328
329pub(crate) fn open_browser(url: &str) -> io::Result<()> {
330 let mut cmd = if cfg!(windows) {
331 let mut c = Command::new("cmd");
332 c.args(["/C", "start", "", url]);
333 c
334 } else if cfg!(target_os = "macos") {
335 let mut c = Command::new("open");
336 c.arg(url);
337 c
338 } else {
339 let mut c = Command::new("xdg-open");
340 c.arg(url);
341 c
342 };
343 cmd.spawn().map(|_| ())
344}