@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_native/src/build.rs

@@ -6,7 +6,8 @@ use std::path::Path;
 use tishlang_compile::ResolvedNativeModule;
 
 /// `tishlang_runtime` Cargo feature names (subset of CLI / compile feature names).
-const RUNTIME_CARGO_FEATURES: &[&str] = &["http", "fs", "process", "regex", "ws"];
+const RUNTIME_CARGO_FEATURES: &[&str] =
+    &["http", "http-hyper", "http-io-uring", "fs", "process", "regex", "ws"];
 
 /// Map CLI/compile features to flags passed to `tishlang_runtime` in the temp crate's Cargo.toml.
 /// `full` enables every optional runtime capability (matches `tish build --feature full` / LANGUAGE.md).
@@ -122,16 +123,12 @@ path = "src/main.rs"
 strip = true
 panic = "abort"
 codegen-units = 1
-lto = "thin"
+lto = "fat"
 
 [dependencies]
 tishlang_runtime = {{ path = {:?}{} }}
 {}{}"#,
-        out_name,
-        runtime_path,
-        features_str,
-        more_deps,
-        ui_dep
+        out_name, runtime_path, features_str, more_deps, ui_dep
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)
@@ -182,4 +179,3 @@ mod tests {
         assert_eq!(f.len(), 5);
     }
 }
-

package/crates/tish_native/src/lib.rs

@@ -80,15 +80,19 @@ pub fn compile_to_native(
             .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(),
             })?;
             let program = {
-                let prog = tishlang_compile::merge_modules(modules).map_err(|e| NativeError {
+                let prog = tishlang_compile::merge_modules(modules)
+                    .map(|m| m.program)
+                    .map_err(|e| NativeError {
                     message: e.to_string(),
                 })?;
                 if optimize {
@@ -121,11 +125,19 @@ 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 {
+                let prog = tishlang_compile::merge_modules(modules)
+                    .map(|m| m.program)
+                    .map_err(|e| NativeError {
                     message: e.to_string(),
                 })?;
                 if optimize {
@@ -180,12 +192,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 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) {
@@ -200,9 +217,7 @@ pub fn compile_program_to_native(
                 &native_build.native_init,
                 optimize,
             )
-            .map_err(|e| NativeError {
-                message: e.message,
-            })?;
+            .map_err(|e| NativeError { message: e.message })?;
             crate::build::build_via_cargo(
                 &rust_code,
                 native_modules,
@@ -220,15 +235,25 @@ pub fn compile_program_to_native(
                     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) {
@@ -236,11 +261,19 @@ pub fn compile_program_to_native(
                     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(),
     }
 }
 
@@ -29,12 +25,14 @@ fn optimize_statement(stmt: &Statement) -> Statement {
         }
         Statement::VarDecl {
             name,
+            name_span,
             mutable,
             type_ann,
             init,
             span,
         } => Statement::VarDecl {
             name: Arc::clone(name),
+            name_span: *name_span,
             mutable: *mutable,
             type_ann: type_ann.clone(),
             init: init.as_ref().map(optimize_expr),
@@ -79,7 +77,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,
             }
         }
@@ -103,11 +103,13 @@ fn optimize_statement(stmt: &Statement) -> Statement {
         },
         Statement::ForOf {
             name,
+            name_span,
             iterable,
             body,
             span,
         } => Statement::ForOf {
             name: Arc::clone(name),
+            name_span: *name_span,
             iterable: optimize_expr(iterable),
             body: Box::new(optimize_statement(body)),
             span: *span,
@@ -121,6 +123,7 @@ fn optimize_statement(stmt: &Statement) -> Statement {
         Statement::FunDecl {
             async_,
             name,
+            name_span,
             params,
             rest_param,
             return_type,
@@ -129,6 +132,7 @@ fn optimize_statement(stmt: &Statement) -> Statement {
         } => Statement::FunDecl {
             async_: *async_,
             name: Arc::clone(name),
+            name_span: *name_span,
             params: params.clone(),
             rest_param: rest_param.clone(),
             return_type: return_type.clone(),
@@ -144,21 +148,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,
@@ -170,17 +165,25 @@ fn optimize_statement(stmt: &Statement) -> Statement {
         Statement::Try {
             body,
             catch_param,
+            catch_param_span,
             catch_body,
             finally_body,
             span,
         } => Statement::Try {
             body: Box::new(optimize_statement(body)),
             catch_param: catch_param.clone(),
+            catch_param_span: *catch_param_span,
             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(),
+        Statement::Import { .. }
+        | Statement::Export { .. }
+        | Statement::TypeAlias { .. }
+        | Statement::DeclareVar { .. }
+        | Statement::DeclareFun { .. } => stmt.clone(),
     }
 }
 
@@ -232,7 +235,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 +332,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,
@@ -362,7 +366,10 @@ fn optimize_expr(expr: &Expr) -> Expr {
         } => {
             let opt_obj = optimize_expr(object);
             let opt_prop = match prop {
-                tishlang_ast::MemberProp::Name(n) => tishlang_ast::MemberProp::Name(Arc::clone(n)),
+                tishlang_ast::MemberProp::Name { name, span } => tishlang_ast::MemberProp::Name {
+                    name: Arc::clone(name),
+                    span: *span,
+                },
                 tishlang_ast::MemberProp::Expr(e) => {
                     tishlang_ast::MemberProp::Expr(Box::new(optimize_expr(e)))
                 }
@@ -385,14 +392,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 +448,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 +492,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 +503,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 +517,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 +717,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 +791,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 +807,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 { .. })));
             }
@@ -163,7 +174,7 @@ mod tests {
             Expr::New { callee, args, .. } => {
                 assert!(matches!(
                     callee.as_ref(),
-                    Expr::Member { prop: tishlang_ast::MemberProp::Name(p), .. } if p.as_ref() == "AudioContext"
+                    Expr::Member { prop: tishlang_ast::MemberProp::Name { name, .. }, .. } if name.as_ref() == "AudioContext"
                 ));
                 assert!(args.is_empty());
             }
@@ -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), .. } => {
-                assert_eq!(p.as_ref(), "bar");
+            Expr::Member {
+                object,
+                prop: tishlang_ast::MemberProp::Name { name, .. },
+                ..
+            } => {
+                assert_eq!(name.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,9 +238,18 @@ 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"),
         }
     }
+
+    #[test]
+    fn stdlib_builtins_d_tish_parses() {
+        const SRC: &str = include_str!("../../../stdlib/builtins.d.tish");
+        parse(SRC).expect("stdlib/builtins.d.tish should parse");
+    }
+
 }