@tishlang/tish 1.5.0 → 1.7.0

package/crates/tish_native/src/build.rs

@@ -28,11 +28,24 @@ fn runtime_features_for_cargo(features: &[String]) -> Vec<String> {
     out
 }
 
+/// Inject `mod generated_native;` after the crate attribute so the binary crate can call `crate::generated_native::…`.
+fn inject_generated_native_mod(rust_code: &str) -> String {
+    if let Some(pos) = rust_code.find("\n\n") {
+        let (a, b) = rust_code.split_at(pos + 2);
+        format!("{}mod generated_native;\n{}", a, b)
+    } else {
+        format!("{}\n\nmod generated_native;\n", rust_code)
+    }
+}
+
 pub fn build_via_cargo(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
     output_path: &Path,
     features: &[String],
+    extra_dependencies_toml: &str,
+    generated_native_rs: Option<&str>,
+    project_root: Option<&Path>,
 ) -> Result<(), String> {
     let out_name = output_path
         .file_stem()
@@ -40,7 +53,7 @@ pub fn build_via_cargo(
         .unwrap_or("tish_out");
     let build_dir = tishlang_build_utils::create_build_dir("tish_build", out_name)?;
 
-    let runtime_path = tishlang_build_utils::find_runtime_path()?;
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
 
     let runtime_features = runtime_features_for_cargo(features);
     let runtime_refs: Vec<&str> = runtime_features.iter().map(String::as_str).collect();
@@ -59,12 +72,28 @@ pub fn build_via_cargo(
 
     let native_deps: String = native_modules
         .iter()
+        .filter(|m| m.use_path_dependency)
         .map(|m| {
             let path = m.crate_path.display().to_string().replace('\\', "/");
             format!("{} = {{ path = {:?} }}\n", m.package_name, path)
         })
         .collect();
 
+    let mut more_deps = String::new();
+    more_deps.push_str(&tokio_dep);
+    if !native_deps.is_empty() {
+        more_deps.push_str(&format!("\n{}", native_deps));
+    }
+    if !extra_dependencies_toml.trim().is_empty() {
+        more_deps.push_str(&format!("\n{}", extra_dependencies_toml));
+    }
+
+    let rust_main = if generated_native_rs.is_some() {
+        inject_generated_native_mod(rust_code)
+    } else {
+        rust_code.to_string()
+    };
+
     let tish_ui_path = std::path::Path::new(&runtime_path)
         .parent()
         .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
@@ -96,23 +125,18 @@ codegen-units = 1
 lto = "thin"
 
 [dependencies]
-tishlang_runtime = {{ path = {:?}{} }}{}{}{}
-"#,
-        out_name,
-        runtime_path,
-        features_str,
-        tokio_dep,
-        if native_deps.is_empty() {
-            String::new()
-        } else {
-            format!("\n{}", native_deps)
-        },
-        ui_dep
+tishlang_runtime = {{ path = {:?}{} }}
+{}{}"#,
+        out_name, runtime_path, features_str, more_deps, ui_dep
     );
 
     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)
+    if let Some(gen) = generated_native_rs {
+        fs::write(build_dir.join("src/generated_native.rs"), gen)
+            .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
+    }
+    fs::write(build_dir.join("src/main.rs"), rust_main)
         .map_err(|e| format!("Cannot write main.rs: {}", e))?;
 
     let workspace_target = Path::new(&runtime_path)
@@ -154,4 +178,3 @@ mod tests {
         assert_eq!(f.len(), 5);
     }
 }
-

package/crates/tish_native/src/lib.rs

@@ -57,28 +57,34 @@ pub fn compile_to_native(
 
     match backend {
         Backend::Rust => {
-            let (rust_code, native_modules, effective_features) = tishlang_compile::compile_project_full(
-                entry_path,
-                project_root,
-                features,
-                optimize,
-            )
-            .map_err(|e| NativeError {
-                message: e.to_string(),
-            })?;
+            let (rust_code, native_modules, effective_features, native_build) =
+                tishlang_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,
                 &effective_features,
+                &native_build.rust_dependencies_toml,
+                native_build.generated_native_rs.as_deref(),
+                project_root,
             )
             .map_err(|e| NativeError { message: e })
         }
         Backend::Cranelift => {
-            let modules = tishlang_compile::resolve_project(entry_path, project_root)
-                .map_err(|e| NativeError {
-                    message: e.to_string(),
+            let modules =
+                tishlang_compile::resolve_project(entry_path, project_root).map_err(|e| {
+                    NativeError {
+                        message: e.to_string(),
+                    }
                 })?;
             tishlang_compile::detect_cycles(&modules).map_err(|e| NativeError {
                 message: e.to_string(),
@@ -96,7 +102,7 @@ pub fn compile_to_native(
 
             if tishlang_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(),
+                    message: "Cranelift backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported. Use --native-backend rust for external modules.".to_string(),
                 });
             }
 
@@ -117,9 +123,15 @@ pub fn compile_to_native(
                 })
         }
         Backend::Llvm => {
-            let modules = tishlang_compile::resolve_project(entry_path, project_root)
-                .map_err(|e| NativeError { message: e.to_string() })?;
-            tishlang_compile::detect_cycles(&modules).map_err(|e| NativeError { message: e.to_string() })?;
+            let modules =
+                tishlang_compile::resolve_project(entry_path, project_root).map_err(|e| {
+                    NativeError {
+                        message: e.to_string(),
+                    }
+                })?;
+            tishlang_compile::detect_cycles(&modules).map_err(|e| NativeError {
+                message: e.to_string(),
+            })?;
             let program = {
                 let prog = tishlang_compile::merge_modules(modules).map_err(|e| NativeError {
                     message: e.to_string(),
@@ -132,7 +144,7 @@ pub fn compile_to_native(
             };
             if tishlang_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(),
+                    message: "LLVM backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
                 });
             }
             let chunk = if optimize {
@@ -176,10 +188,17 @@ pub fn compile_program_to_native(
 
     match backend {
         Backend::Rust => {
-            let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };
+            let program = if optimize {
+                tishlang_opt::optimize(program)
+            } else {
+                program.clone()
+            };
             let root = project_root.unwrap_or_else(|| Path::new("."));
             let native_modules = tishlang_compile::resolve_native_modules(&program, root)
                 .map_err(|e| NativeError { message: e })?;
+            let native_build =
+                tishlang_compile::compute_native_build_artifacts(&program, root, &native_modules)
+                    .map_err(|e| NativeError { message: e })?;
             let mut all_features = features.to_vec();
             for f in tishlang_compile::extract_native_import_features(&program) {
                 if !all_features.contains(&f) {
@@ -191,41 +210,66 @@ pub fn compile_program_to_native(
                 project_root,
                 &all_features,
                 &native_modules,
+                &native_build.native_init,
                 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 })
+            .map_err(|e| NativeError { message: e.message })?;
+            crate::build::build_via_cargo(
+                &rust_code,
+                native_modules,
+                output_path,
+                &all_features,
+                &native_build.rust_dependencies_toml,
+                native_build.generated_native_rs.as_deref(),
+                Some(root),
+            )
+            .map_err(|e| NativeError { message: e })
         }
         Backend::Cranelift => {
             if tishlang_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(),
+                    message: "Cranelift backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
                 });
             }
-            let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };
+            let program = if optimize {
+                tishlang_opt::optimize(program)
+            } else {
+                program.clone()
+            };
             let chunk = if optimize {
-                tishlang_bytecode::compile(&program).map_err(|e| NativeError { message: e.to_string() })?
+                tishlang_bytecode::compile(&program).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?
             } else {
-                tishlang_bytecode::compile_unoptimized(&program).map_err(|e| NativeError { message: e.to_string() })?
+                tishlang_bytecode::compile_unoptimized(&program).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?
             };
             let cranelift_features = tishlang_compile::extract_native_import_features(&program);
             tishlang_cranelift::compile_chunk_to_native(&chunk, output_path, &cranelift_features)
-                .map_err(|e| NativeError { message: e.to_string() })
+                .map_err(|e| NativeError {
+                    message: e.to_string(),
+                })
         }
         Backend::Llvm => {
             if tishlang_compile::has_external_native_imports(program) {
                 return Err(NativeError {
-                    message: "LLVM backend does not support external native imports.".to_string(),
+                    message: "LLVM backend does not support external native imports (tish:…, cargo:…, @scope/pkg).".to_string(),
                 });
             }
-            let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };
+            let program = if optimize {
+                tishlang_opt::optimize(program)
+            } else {
+                program.clone()
+            };
             let chunk = if optimize {
-                tishlang_bytecode::compile(&program).map_err(|e| NativeError { message: e.to_string() })?
+                tishlang_bytecode::compile(&program).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?
             } else {
-                tishlang_bytecode::compile_unoptimized(&program).map_err(|e| NativeError { message: e.to_string() })?
+                tishlang_bytecode::compile_unoptimized(&program).map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?
             };
             let llvm_features = tishlang_compile::extract_native_import_features(&program);
             tishlang_llvm::compile_chunk_to_native(&chunk, output_path, &llvm_features)

package/crates/tish_opt/src/lib.rs

@@ -10,11 +10,7 @@ use tishlang_ast::{ArrowBody, BinOp, Expr, Literal, Program, Statement, UnaryOp}
 /// Optimize a Tish program. Returns a new program with transformations applied.
 pub fn optimize(program: &Program) -> Program {
     Program {
-        statements: program
-            .statements
-            .iter()
-            .map(optimize_statement)
-            .collect(),
+        statements: program.statements.iter().map(optimize_statement).collect(),
     }
 }
 
@@ -79,7 +75,9 @@ fn optimize_statement(stmt: &Statement) -> Statement {
             Statement::If {
                 cond: opt_cond,
                 then_branch: Box::new(optimize_statement(then_branch)),
-                else_branch: else_branch.as_ref().map(|b| Box::new(optimize_statement(b))),
+                else_branch: else_branch
+                    .as_ref()
+                    .map(|b| Box::new(optimize_statement(b))),
                 span: *span,
             }
         }
@@ -144,21 +142,12 @@ fn optimize_statement(stmt: &Statement) -> Statement {
             expr: optimize_expr(expr),
             cases: cases
                 .iter()
-                .map(|(ce, stmts)| {
-                    (
-                        ce.as_ref().map(optimize_expr),
-                        optimize_block(stmts),
-                    )
-                })
+                .map(|(ce, stmts)| (ce.as_ref().map(optimize_expr), optimize_block(stmts)))
                 .collect(),
             default_body: default_body.as_ref().map(|stmts| optimize_block(stmts)),
             span: *span,
         },
-        Statement::DoWhile {
-            body,
-            cond,
-            span,
-        } => Statement::DoWhile {
+        Statement::DoWhile { body, cond, span } => Statement::DoWhile {
             body: Box::new(optimize_statement(body)),
             cond: optimize_expr(cond),
             span: *span,
@@ -177,7 +166,9 @@ fn optimize_statement(stmt: &Statement) -> Statement {
             body: Box::new(optimize_statement(body)),
             catch_param: catch_param.clone(),
             catch_body: catch_body.as_ref().map(|b| Box::new(optimize_statement(b))),
-            finally_body: finally_body.as_ref().map(|b| Box::new(optimize_statement(b))),
+            finally_body: finally_body
+                .as_ref()
+                .map(|b| Box::new(optimize_statement(b))),
             span: *span,
         },
         Statement::Import { .. } | Statement::Export { .. } => stmt.clone(),
@@ -232,7 +223,12 @@ fn optimize_expr(expr: &Expr) -> Expr {
             name: Arc::clone(name),
             span: *span,
         },
-        Expr::Binary { left, op, right, span } => {
+        Expr::Binary {
+            left,
+            op,
+            right,
+            span,
+        } => {
             let opt_left = optimize_expr(left);
             let opt_right = optimize_expr(right);
 
@@ -324,32 +320,28 @@ fn optimize_expr(expr: &Expr) -> Expr {
                 span: *span,
             }
         }
-        Expr::Call {
-            callee,
-            args,
-            span,
-        } => Expr::Call {
+        Expr::Call { callee, args, span } => Expr::Call {
             callee: Box::new(optimize_expr(callee)),
             args: args
                 .iter()
                 .map(|a| match a {
                     tishlang_ast::CallArg::Expr(e) => tishlang_ast::CallArg::Expr(optimize_expr(e)),
-                    tishlang_ast::CallArg::Spread(e) => tishlang_ast::CallArg::Spread(optimize_expr(e)),
+                    tishlang_ast::CallArg::Spread(e) => {
+                        tishlang_ast::CallArg::Spread(optimize_expr(e))
+                    }
                 })
                 .collect(),
             span: *span,
         },
-        Expr::New {
-            callee,
-            args,
-            span,
-        } => Expr::New {
+        Expr::New { callee, args, span } => Expr::New {
             callee: Box::new(optimize_expr(callee)),
             args: args
                 .iter()
                 .map(|a| match a {
                     tishlang_ast::CallArg::Expr(e) => tishlang_ast::CallArg::Expr(optimize_expr(e)),
-                    tishlang_ast::CallArg::Spread(e) => tishlang_ast::CallArg::Spread(optimize_expr(e)),
+                    tishlang_ast::CallArg::Spread(e) => {
+                        tishlang_ast::CallArg::Spread(optimize_expr(e))
+                    }
                 })
                 .collect(),
             span: *span,
@@ -385,14 +377,11 @@ fn optimize_expr(expr: &Expr) -> Expr {
             optional: *optional,
             span: *span,
         },
-        Expr::NullishCoalesce {
-            left,
-            right,
-            span,
-        } => {
+        Expr::NullishCoalesce { left, right, span } => {
             let opt_left = optimize_expr(left);
             if let Expr::Literal {
-                value: Literal::Null, ..
+                value: Literal::Null,
+                ..
             } = &opt_left
             {
                 return optimize_expr(right);
@@ -444,13 +433,23 @@ fn optimize_expr(expr: &Expr) -> Expr {
         | Expr::PostfixDec { .. }
         | Expr::PrefixInc { .. }
         | Expr::PrefixDec { .. } => expr.clone(),
-        Expr::CompoundAssign { name, op, value, span } => Expr::CompoundAssign {
+        Expr::CompoundAssign {
+            name,
+            op,
+            value,
+            span,
+        } => Expr::CompoundAssign {
             name: Arc::clone(name),
             op: *op,
             value: Box::new(optimize_expr(value)),
             span: *span,
         },
-        Expr::LogicalAssign { name, op, value, span } => Expr::LogicalAssign {
+        Expr::LogicalAssign {
+            name,
+            op,
+            value,
+            span,
+        } => Expr::LogicalAssign {
             name: Arc::clone(name),
             op: *op,
             value: Box::new(optimize_expr(value)),
@@ -478,11 +477,7 @@ fn optimize_expr(expr: &Expr) -> Expr {
             value: Box::new(optimize_expr(value)),
             span: *span,
         },
-        Expr::ArrowFunction {
-            params,
-            body,
-            span,
-        } => {
+        Expr::ArrowFunction { params, body, span } => {
             let opt_body = match body {
                 ArrowBody::Expr(e) => ArrowBody::Expr(Box::new(optimize_expr(e))),
                 ArrowBody::Block(s) => ArrowBody::Block(Box::new(optimize_statement(s))),
@@ -493,7 +488,11 @@ fn optimize_expr(expr: &Expr) -> Expr {
                 span: *span,
             }
         }
-        Expr::TemplateLiteral { quasis, exprs, span } => Expr::TemplateLiteral {
+        Expr::TemplateLiteral {
+            quasis,
+            exprs,
+            span,
+        } => Expr::TemplateLiteral {
             quasis: quasis.iter().map(Arc::clone).collect(),
             exprs: exprs.iter().map(optimize_expr).collect(),
             span: *span,
@@ -503,7 +502,11 @@ fn optimize_expr(expr: &Expr) -> Expr {
             span: *span,
         },
         Expr::JsxElement { .. } | Expr::JsxFragment { .. } => expr.clone(),
-        Expr::NativeModuleLoad { spec, export_name, span } => Expr::NativeModuleLoad {
+        Expr::NativeModuleLoad {
+            spec,
+            export_name,
+            span,
+        } => Expr::NativeModuleLoad {
             spec: Arc::clone(spec),
             export_name: Arc::clone(export_name),
             span: *span,
@@ -699,8 +702,12 @@ fn try_fold_binop(left: &Literal, op: BinOp, right: &Literal) -> Option<Literal>
         Add => {
             if matches!(left, Literal::String(_)) || matches!(right, Literal::String(_)) {
                 return Some(Literal::String(
-                    format!("{}{}", literal_to_display_string(left), literal_to_display_string(right))
-                        .into(),
+                    format!(
+                        "{}{}",
+                        literal_to_display_string(left),
+                        literal_to_display_string(right)
+                    )
+                    .into(),
                 ));
             }
             Literal::Number(ln + rn)
@@ -769,7 +776,11 @@ mod tests {
             [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
-        assert!(has_literal_number(expr, -42.0), "expected -42, got {:?}", expr);
+        assert!(
+            has_literal_number(expr, -42.0),
+            "expected -42, got {:?}",
+            expr
+        );
     }
 
     #[test]
@@ -781,7 +792,13 @@ mod tests {
             _ => panic!("expected single expr stmt"),
         };
         assert!(
-            matches!(expr, Expr::Literal { value: Literal::Bool(false), .. }),
+            matches!(
+                expr,
+                Expr::Literal {
+                    value: Literal::Bool(false),
+                    ..
+                }
+            ),
             "expected false, got {:?}",
             expr
         );

package/crates/tish_parser/src/lib.rs

@@ -38,7 +38,9 @@ mod tests {
         assert_eq!(program.statements.len(), 1);
         let stmt = &program.statements[0];
         let init = match stmt {
-            Statement::VarDecl { init: Some(ref i), .. } => i,
+            Statement::VarDecl {
+                init: Some(ref i), ..
+            } => i,
             _ => panic!("expected VarDecl with init"),
         };
         let props = match init {
@@ -61,11 +63,14 @@ mod tests {
 
     #[test]
     fn test_object_literal_string_key() {
-        let program = parse(r#"const o = { "ai-a": 0, human: 1 }"#).expect("parse object with string key");
+        let program =
+            parse(r#"const o = { "ai-a": 0, human: 1 }"#).expect("parse object with string key");
         assert_eq!(program.statements.len(), 1);
         let stmt = &program.statements[0];
         let init = match stmt {
-            Statement::VarDecl { init: Some(ref i), .. } => i,
+            Statement::VarDecl {
+                init: Some(ref i), ..
+            } => i,
             _ => panic!("expected VarDecl with init"),
         };
         let props = match init {
@@ -89,7 +94,9 @@ mod tests {
         assert_eq!(program.statements.len(), 1);
         let stmt = &program.statements[0];
         let init = match stmt {
-            Statement::VarDecl { init: Some(ref i), .. } => i,
+            Statement::VarDecl {
+                init: Some(ref i), ..
+            } => i,
             _ => panic!("expected VarDecl with init"),
         };
         let props = match init {
@@ -134,7 +141,9 @@ mod tests {
         let e = unwrap_expr_stmt(&program);
         match e {
             Expr::New { callee, args, .. } => {
-                assert!(matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Foo"));
+                assert!(
+                    matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Foo")
+                );
                 assert!(args.is_empty());
             }
             _ => panic!("expected New, got {:?}", e),
@@ -147,7 +156,9 @@ mod tests {
         let e = unwrap_expr_stmt(&program);
         match e {
             Expr::New { callee, args, .. } => {
-                assert!(matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Uint8Array"));
+                assert!(
+                    matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Uint8Array")
+                );
                 assert_eq!(args.len(), 1);
                 assert!(matches!(&args[0], CallArg::Expr(Expr::Literal { .. })));
             }
@@ -179,8 +190,14 @@ mod tests {
             Expr::New { callee, args, .. } => {
                 assert!(args.is_empty());
                 match callee.as_ref() {
-                    Expr::New { callee: inner, args: inner_args, .. } => {
-                        assert!(matches!(inner.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Date"));
+                    Expr::New {
+                        callee: inner,
+                        args: inner_args,
+                        ..
+                    } => {
+                        assert!(
+                            matches!(inner.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Date")
+                        );
                         assert!(inner_args.is_empty());
                     }
                     _ => panic!("expected nested New"),
@@ -195,11 +212,17 @@ mod tests {
         let program = parse("new Foo().bar").expect("parse");
         let e = unwrap_expr_stmt(&program);
         match e {
-            Expr::Member { object, prop: tishlang_ast::MemberProp::Name(p), .. } => {
+            Expr::Member {
+                object,
+                prop: tishlang_ast::MemberProp::Name(p),
+                ..
+            } => {
                 assert_eq!(p.as_ref(), "bar");
                 match object.as_ref() {
                     Expr::New { callee, args, .. } => {
-                        assert!(matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Foo"));
+                        assert!(
+                            matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Foo")
+                        );
                         assert!(args.is_empty());
                     }
                     _ => panic!("expected New object"),
@@ -215,7 +238,9 @@ mod tests {
         let e = unwrap_expr_stmt(&program);
         match e {
             Expr::New { args, .. } => {
-                assert!(matches!(&args[0], CallArg::Spread(Expr::Ident { name, .. }) if name.as_ref() == "xs"));
+                assert!(
+                    matches!(&args[0], CallArg::Spread(Expr::Ident { name, .. }) if name.as_ref() == "xs")
+                );
             }
             _ => panic!("expected New"),
         }