Skip to main content

code_transpiler/
lib.rs

1//! Pure-Rust incremental port of Code-Transpiler.
2//!
3//! No Go executable, DLL, external compiler process, or `CODETRANSPILER_BACKEND`
4//! is used. The native core currently parses a conservative Go subset into a
5//! neutral IR and emits Rust, Python, Julia, C, and C++ while failing closed for
6//! syntax whose semantics are not yet implemented.
7
8mod 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
180/// Routes implemented without an external fallback.
181pub 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}