@tishlang/tish 1.0.6 → 1.0.10

package/crates/tish_native/src/build.rs

@@ -0,0 +1,102 @@
+//! Build native binary via cargo (interim path until Cranelift backend is ready).
+
+use std::fs;
+use std::path::Path;
+
+use tish_compile::ResolvedNativeModule;
+
+pub fn build_via_cargo(
+    rust_code: &str,
+    native_modules: Vec<ResolvedNativeModule>,
+    output_path: &Path,
+    features: &[String],
+) -> Result<(), String> {
+    let out_name = output_path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("tish_out");
+    let build_dir = tish_build_utils::create_build_dir("tish_build", out_name)?;
+
+    let runtime_path = tish_build_utils::find_runtime_path()?;
+
+    let runtime_features: Vec<&str> = features
+        .iter()
+        .filter(|f| ["http", "fs", "process", "regex", "ws"].contains(&f.as_str()))
+        .map(String::as_str)
+        .collect();
+    let features_str = if runtime_features.is_empty() {
+        String::new()
+    } else {
+        format!(", features = {:?}", runtime_features)
+    };
+
+    let needs_tokio = rust_code.contains("#[tokio::main]");
+    let tokio_dep = if needs_tokio {
+        "\ntokio = { version = \"1\", features = [\"rt-multi-thread\", \"macros\"] }\n"
+    } else {
+        ""
+    };
+
+    let native_deps: String = native_modules
+        .iter()
+        .map(|m| {
+            let path = m.crate_path.display().to_string().replace('\\', "/");
+            format!("{} = {{ path = {:?} }}\n", m.package_name, path)
+        })
+        .collect();
+
+    let cargo_toml = format!(
+        r#"[package]
+name = "tish_output"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "{}"
+path = "src/main.rs"
+
+[profile.release]
+# Reduce binary size: strip symbols, abort on panic (no unwinding), single codegen unit
+strip = true
+panic = "abort"
+codegen-units = 1
+lto = "thin"
+
+[dependencies]
+tish_runtime = {{ path = {:?}{} }}{}{}
+"#,
+        out_name,
+        runtime_path,
+        features_str,
+        tokio_dep,
+        if native_deps.is_empty() {
+            String::new()
+        } else {
+            format!("\n{}", native_deps)
+        }
+    );
+
+    fs::write(build_dir.join("Cargo.toml"), cargo_toml)
+        .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
+    fs::write(build_dir.join("src/main.rs"), rust_code)
+        .map_err(|e| format!("Cannot write main.rs: {}", e))?;
+
+    let workspace_target = Path::new(&runtime_path)
+        .parent()
+        .and_then(|p| p.parent())
+        .map(|ws| ws.join("target"));
+    let target_dir = workspace_target.filter(|p| p.exists());
+    let binary_dir = target_dir
+        .as_ref()
+        .map(|t| t.join("release"))
+        .unwrap_or_else(|| build_dir.join("target").join("release"));
+
+    tish_build_utils::run_cargo_build(&build_dir, target_dir.as_deref())?;
+
+    let binary = tish_build_utils::find_release_binary(&binary_dir, out_name)?;
+    let target = tish_build_utils::resolve_output_path(output_path, out_name);
+    tish_build_utils::copy_binary_to_output(&binary, &target)?;
+
+    Ok(())
+}
+

package/crates/tish_native/src/lib.rs

@@ -0,0 +1,237 @@
+//! Native code generation backend for Tish.
+//!
+//! Target architecture (per plan):
+//! - Phase 2: Bytecode -> Cranelift IR -> .o -> link with minimal runtime
+//! - Current: Delegates to tish_compile (Rust codegen) + cargo build as interim path
+//!
+//! Once Cranelift backend is implemented, this crate will:
+//! 1. Take Chunk (bytecode) as input
+//! 2. Lower to Cranelift IR
+//! 3. Emit .o via cranelift-object
+//! 4. Link against prebuilt tish_runtime staticlib
+
+mod build;
+
+use std::path::Path;
+use tish_ast::Program;
+
+/// Error from native compilation.
+#[derive(Debug)]
+pub struct NativeError {
+    pub message: String,
+}
+
+impl std::fmt::Display for NativeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for NativeError {}
+
+/// Compile a Tish project to a native binary.
+///
+/// - `native_backend == "rust"`: Full Rust codegen + cargo build (supports native imports).
+/// - `native_backend == "cranelift"`: Bytecode -> Cranelift -> native (pure Tish only).
+/// - `native_backend == "llvm"`: Experimental LLVM backend (not implemented yet).
+pub fn compile_to_native(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    features: &[String],
+    native_backend: &str,
+    optimize: bool,
+) -> Result<(), NativeError> {
+    let backend = match native_backend {
+        "rust" => Backend::Rust,
+        "cranelift" => Backend::Cranelift,
+        "llvm" => Backend::Llvm,
+        _ => {
+            return Err(NativeError {
+                message: format!(
+                    "Invalid native backend '{}'. Use 'rust', 'cranelift', or 'llvm'.",
+                    native_backend
+                ),
+            });
+        }
+    };
+
+    match backend {
+        Backend::Rust => {
+            let (rust_code, native_modules) = tish_compile::compile_project_full(
+                entry_path,
+                project_root,
+                features,
+                optimize,
+            )
+            .map_err(|e| NativeError {
+                message: e.to_string(),
+            })?;
+
+            crate::build::build_via_cargo(&rust_code, native_modules, output_path, features)
+                .map_err(|e| NativeError { message: e })
+        }
+        Backend::Cranelift => {
+            let modules = tish_compile::resolve_project(entry_path, project_root)
+                .map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?;
+            tish_compile::detect_cycles(&modules).map_err(|e| NativeError {
+                message: e.to_string(),
+            })?;
+            let program = {
+                let prog = tish_compile::merge_modules(modules).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?;
+                if optimize {
+                    tish_opt::optimize(&prog)
+                } else {
+                    prog
+                }
+            };
+
+            if tish_compile::has_external_native_imports(&program) {
+                return Err(NativeError {
+                    message: "Cranelift backend does not support external native imports (tish:egui, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported. Use --native-backend rust for external modules.".to_string(),
+                });
+            }
+
+            let chunk = if optimize {
+                tish_bytecode::compile(&program).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?
+            } else {
+                tish_bytecode::compile_unoptimized(&program).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?
+            };
+
+            let cranelift_features = tish_compile::extract_native_import_features(&program);
+            tish_cranelift::compile_chunk_to_native(&chunk, output_path, &cranelift_features)
+                .map_err(|e| NativeError {
+                    message: e.to_string(),
+                })
+        }
+        Backend::Llvm => {
+            let modules = tish_compile::resolve_project(entry_path, project_root)
+                .map_err(|e| NativeError { message: e.to_string() })?;
+            tish_compile::detect_cycles(&modules).map_err(|e| NativeError { message: e.to_string() })?;
+            let program = {
+                let prog = tish_compile::merge_modules(modules).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?;
+                if optimize {
+                    tish_opt::optimize(&prog)
+                } else {
+                    prog
+                }
+            };
+            if tish_compile::has_external_native_imports(&program) {
+                return Err(NativeError {
+                    message: "LLVM backend does not support external native imports. Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
+                });
+            }
+            let chunk = if optimize {
+                tish_bytecode::compile(&program).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?
+            } else {
+                tish_bytecode::compile_unoptimized(&program).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?
+            };
+            let llvm_features = tish_compile::extract_native_import_features(&program);
+            tish_llvm::compile_chunk_to_native(&chunk, output_path, &llvm_features)
+                .map_err(|e| NativeError { message: e.message })
+        }
+    }
+}
+
+/// Compile a single Program (e.g. from js_to_tish) to native.
+pub fn compile_program_to_native(
+    program: &Program,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    features: &[String],
+    native_backend: &str,
+    optimize: bool,
+) -> Result<(), NativeError> {
+    let backend = match native_backend {
+        "rust" => Backend::Rust,
+        "cranelift" => Backend::Cranelift,
+        "llvm" => Backend::Llvm,
+        _ => {
+            return Err(NativeError {
+                message: format!(
+                    "Invalid native backend '{}'. Use 'rust', 'cranelift', or 'llvm'.",
+                    native_backend
+                ),
+            });
+        }
+    };
+
+    match backend {
+        Backend::Rust => {
+            let program = if optimize { tish_opt::optimize(program) } else { program.clone() };
+            let root = project_root.unwrap_or_else(|| Path::new("."));
+            let native_modules = tish_compile::resolve_native_modules(&program, root)
+                .map_err(|e| NativeError { message: e })?;
+            let mut all_features = features.to_vec();
+            for f in tish_compile::extract_native_import_features(&program) {
+                if !all_features.contains(&f) {
+                    all_features.push(f);
+                }
+            }
+            let rust_code = tish_compile::compile_with_native_modules(
+                &program,
+                project_root,
+                &all_features,
+                &native_modules,
+                optimize,
+            )
+            .map_err(|e| NativeError {
+                message: e.message,
+            })?;
+            crate::build::build_via_cargo(&rust_code, native_modules, output_path, &all_features)
+                .map_err(|e| NativeError { message: e })
+        }
+        Backend::Cranelift => {
+            if tish_compile::has_external_native_imports(program) {
+                return Err(NativeError {
+                    message: "Cranelift backend does not support external native imports. Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
+                });
+            }
+            let program = if optimize { tish_opt::optimize(program) } else { program.clone() };
+            let chunk = if optimize {
+                tish_bytecode::compile(&program).map_err(|e| NativeError { message: e.to_string() })?
+            } else {
+                tish_bytecode::compile_unoptimized(&program).map_err(|e| NativeError { message: e.to_string() })?
+            };
+            let cranelift_features = tish_compile::extract_native_import_features(&program);
+            tish_cranelift::compile_chunk_to_native(&chunk, output_path, &cranelift_features)
+                .map_err(|e| NativeError { message: e.to_string() })
+        }
+        Backend::Llvm => {
+            if tish_compile::has_external_native_imports(program) {
+                return Err(NativeError {
+                    message: "LLVM backend does not support external native imports.".to_string(),
+                });
+            }
+            let program = if optimize { tish_opt::optimize(program) } else { program.clone() };
+            let chunk = if optimize {
+                tish_bytecode::compile(&program).map_err(|e| NativeError { message: e.to_string() })?
+            } else {
+                tish_bytecode::compile_unoptimized(&program).map_err(|e| NativeError { message: e.to_string() })?
+            };
+            let llvm_features = tish_compile::extract_native_import_features(&program);
+            tish_llvm::compile_chunk_to_native(&chunk, output_path, &llvm_features)
+                .map_err(|e| NativeError { message: e.message })
+        }
+    }
+}
+
+enum Backend {
+    Rust,
+    Cranelift,
+    Llvm,
+}

package/crates/tish_opt/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "tish_opt"
+version = "0.1.0"
+edition = "2021"
+description = "AST optimization pass for Tish (constant folding, short-circuit, etc.)"
+
+[dependencies]
+tish_ast = { path = "../tish_ast" }
+
+[dev-dependencies]
+tish_parser = { path = "../tish_parser" }