@tishlang/tish 1.0.13 → 1.0.15

package/crates/tish_opt/src/lib.rs

@@ -5,7 +5,7 @@
 
 use std::sync::Arc;
 
-use tish_ast::{ArrowBody, BinOp, Expr, Literal, Program, Statement, UnaryOp};
+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 {
@@ -333,8 +333,8 @@ fn optimize_expr(expr: &Expr) -> Expr {
             args: args
                 .iter()
                 .map(|a| match a {
-                    tish_ast::CallArg::Expr(e) => tish_ast::CallArg::Expr(optimize_expr(e)),
-                    tish_ast::CallArg::Spread(e) => tish_ast::CallArg::Spread(optimize_expr(e)),
+                    tishlang_ast::CallArg::Expr(e) => tishlang_ast::CallArg::Expr(optimize_expr(e)),
+                    tishlang_ast::CallArg::Spread(e) => tishlang_ast::CallArg::Spread(optimize_expr(e)),
                 })
                 .collect(),
             span: *span,
@@ -347,9 +347,9 @@ fn optimize_expr(expr: &Expr) -> Expr {
         } => {
             let opt_obj = optimize_expr(object);
             let opt_prop = match prop {
-                tish_ast::MemberProp::Name(n) => tish_ast::MemberProp::Name(Arc::clone(n)),
-                tish_ast::MemberProp::Expr(e) => {
-                    tish_ast::MemberProp::Expr(Box::new(optimize_expr(e)))
+                tishlang_ast::MemberProp::Name(n) => tishlang_ast::MemberProp::Name(Arc::clone(n)),
+                tishlang_ast::MemberProp::Expr(e) => {
+                    tishlang_ast::MemberProp::Expr(Box::new(optimize_expr(e)))
                 }
             };
             Expr::Member {
@@ -392,11 +392,11 @@ fn optimize_expr(expr: &Expr) -> Expr {
             elements: elements
                 .iter()
                 .map(|e| match e {
-                    tish_ast::ArrayElement::Expr(ex) => {
-                        tish_ast::ArrayElement::Expr(optimize_expr(ex))
+                    tishlang_ast::ArrayElement::Expr(ex) => {
+                        tishlang_ast::ArrayElement::Expr(optimize_expr(ex))
                     }
-                    tish_ast::ArrayElement::Spread(ex) => {
-                        tish_ast::ArrayElement::Spread(optimize_expr(ex))
+                    tishlang_ast::ArrayElement::Spread(ex) => {
+                        tishlang_ast::ArrayElement::Spread(optimize_expr(ex))
                     }
                 })
                 .collect(),
@@ -406,11 +406,11 @@ fn optimize_expr(expr: &Expr) -> Expr {
             props: props
                 .iter()
                 .map(|p| match p {
-                    tish_ast::ObjectProp::KeyValue(k, v) => {
-                        tish_ast::ObjectProp::KeyValue(Arc::clone(k), optimize_expr(v))
+                    tishlang_ast::ObjectProp::KeyValue(k, v) => {
+                        tishlang_ast::ObjectProp::KeyValue(Arc::clone(k), optimize_expr(v))
                     }
-                    tish_ast::ObjectProp::Spread(e) => {
-                        tish_ast::ObjectProp::Spread(optimize_expr(e))
+                    tishlang_ast::ObjectProp::Spread(e) => {
+                        tishlang_ast::ObjectProp::Spread(optimize_expr(e))
                     }
                 })
                 .collect(),
@@ -556,7 +556,7 @@ fn try_algebraic_simplify(
     op: BinOp,
     left: &Expr,
     right: &Expr,
-    span: tish_ast::Span,
+    span: tishlang_ast::Span,
 ) -> Option<Expr> {
     use BinOp::*;
     fn num_is_zero(n: f64) -> bool {
@@ -720,7 +720,7 @@ mod tests {
     use super::*;
 
     fn program_from_source(src: &str) -> Program {
-        tish_parser::parse(src).expect("parse")
+        tishlang_parser::parse(src).expect("parse")
     }
 
     fn has_literal_number(expr: &Expr, n: f64) -> bool {
@@ -740,7 +740,7 @@ mod tests {
         let program = program_from_source("1 + 2");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(has_literal_number(expr, 3.0), "expected 3, got {:?}", expr);
@@ -751,7 +751,7 @@ mod tests {
         let program = program_from_source("-42");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(has_literal_number(expr, -42.0), "expected -42, got {:?}", expr);
@@ -762,7 +762,7 @@ mod tests {
         let program = program_from_source("false && foo");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(
@@ -777,7 +777,7 @@ mod tests {
         let program = program_from_source("true ? 1 : 2");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(has_literal_number(expr, 1.0), "expected 1, got {:?}", expr);
@@ -789,7 +789,7 @@ mod tests {
         let program = program_from_source("x + 0");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(
@@ -804,7 +804,7 @@ mod tests {
         let program = program_from_source("x * 1");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(
@@ -820,7 +820,7 @@ mod tests {
         let program = program_from_source("x * (1 + 0)");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(
@@ -835,7 +835,7 @@ mod tests {
         let program = program_from_source("x ** 1");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(
@@ -850,7 +850,7 @@ mod tests {
         let program = program_from_source("x ** 0");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(has_literal_number(expr, 1.0), "expected 1, got {:?}", expr);
@@ -861,7 +861,7 @@ mod tests {
         let program = program_from_source("1 ** x");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(has_literal_number(expr, 1.0), "expected 1, got {:?}", expr);
@@ -872,7 +872,7 @@ mod tests {
         let program = program_from_source("null ?? x");
         let opt = optimize(&program);
         let expr = match &opt.statements[..] {
-            [tish_ast::Statement::ExprStmt { expr, .. }] => expr,
+            [tishlang_ast::Statement::ExprStmt { expr, .. }] => expr,
             _ => panic!("expected single expr stmt"),
         };
         assert!(

package/crates/tish_parser/Cargo.toml

@@ -1,9 +1,11 @@
 [package]
-name = "tish_parser"
+name = "tishlang_parser"
 version = "0.1.0"
 edition = "2021"
 description = "Tish recursive descent parser"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [dependencies]
-tish_lexer = { path = "../tish_lexer" }
-tish_ast = { path = "../tish_ast" }
+tishlang_lexer = { path = "../tish_lexer" }
+tishlang_ast = { path = "../tish_ast" }

package/crates/tish_parser/src/lib.rs

@@ -4,8 +4,8 @@ mod parser;
 
 use parser::Parser;
 
-use tish_ast::Program;
-use tish_lexer::Lexer;
+use tishlang_ast::Program;
+use tishlang_lexer::Lexer;
 
 pub fn parse(source: &str) -> Result<Program, String> {
     let lexer = Lexer::new(source);
@@ -18,13 +18,13 @@ pub fn parse(source: &str) -> Result<Program, String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tish_ast::{Expr, ObjectProp, Statement};
+    use tishlang_ast::{Expr, ObjectProp, Statement};
 
     #[test]
     fn test_async_fn_parse() {
         let program = parse("async fn foo() { }").expect("parse async fn");
         assert_eq!(program.statements.len(), 1);
-        if let tish_ast::Statement::FunDecl { async_, name, .. } = &program.statements[0] {
+        if let tishlang_ast::Statement::FunDecl { async_, name, .. } = &program.statements[0] {
             assert!(async_, "expected async function");
             assert_eq!(name.as_ref(), "foo");
         } else {

package/crates/tish_parser/src/parser.rs

@@ -51,13 +51,13 @@ macro_rules! binary_multi_op {
     };
 }
 
-use tish_ast::{
+use tishlang_ast::{
     ArrowBody, ArrayElement, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
     DestructProp, ExportDeclaration, Expr, ImportSpecifier, JsxAttrValue, JsxChild, JsxProp,
     Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement, TypeAnnotation,
     TypedParam, UnaryOp,
 };
-use tish_lexer::{Token, TokenKind};
+use tishlang_lexer::{Token, TokenKind};
 
 pub struct Parser<'a> {
     tokens: &'a [Token],

package/crates/tish_runtime/Cargo.toml

@@ -1,21 +1,23 @@
 [package]
-name = "tish_runtime"
+name = "tishlang_runtime"
 version = "0.1.0"
 edition = "2021"
 description = "Minimal runtime for Tish compiled output"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [features]
 default = []
-http = ["tokio", "reqwest", "futures", "bytes", "tiny_http", "tish_core/regex"]
+http = ["tokio", "reqwest", "futures", "bytes", "tiny_http", "tishlang_core/regex"]
 fs = []
 process = []
-regex = ["tish_core/regex"]
+regex = ["tishlang_core/regex"]
 # WebSocket (JS-like API). Modular: import { WebSocket, Server } from 'tish:ws'
 ws = ["tokio", "tokio/net", "tokio/io-util", "tokio-tungstenite", "futures-util", "lazy_static"]
 
 [dependencies]
-tish_core = { path = "../tish_core" }
-tish_builtins = { path = "../tish_builtins" }
+tishlang_core = { path = "../tish_core" }
+tishlang_builtins = { path = "../tish_builtins" }
 tokio = { version = "1.50.0", features = ["rt-multi-thread", "macros", "time", "sync"], optional = true }
 reqwest = { version = "0.13.2", default-features = false, features = ["rustls", "json", "stream"], optional = true }
 futures = { version = "0.3.32", optional = true }

package/crates/tish_runtime/src/http.rs

@@ -6,7 +6,7 @@ use std::fs::File;
 use std::io::Write;
 use std::rc::Rc;
 use std::sync::Arc;
-use tish_core::Value;
+use tishlang_core::Value;
 use tokio::runtime::Runtime;
 
 thread_local! {

package/crates/tish_runtime/src/http_fetch.rs

@@ -9,7 +9,7 @@ use std::sync::{Arc, Mutex};
 use bytes::Bytes;
 use futures::Stream;
 use futures::StreamExt;
-use tish_core::{NativeFn, TishOpaque, TishPromise, Value};
+use tishlang_core::{NativeFn, TishOpaque, TishPromise, Value};
 
 use crate::http::{build_error_response, extract_body, extract_headers, extract_method};
 
@@ -115,7 +115,7 @@ impl TishPromise for JsonTextPromise {
         if let Some(rx) = rx {
             let r = crate::http::block_on_http(rx);
             match r {
-                Ok(Ok(s)) => match tish_core::json_parse(&s) {
+                Ok(Ok(s)) => match tishlang_core::json_parse(&s) {
                     Ok(v) => Ok(v),
                     Err(e) => Err({
                         let mut obj = HashMap::new();

package/crates/tish_runtime/src/lib.rs

@@ -1,6 +1,6 @@
 //! Minimal runtime for Tish compiled output.
 //!
-//! Re-exports core types from tish_core and provides console, Math,
+//! Re-exports core types from tishlang_core and provides console, Math,
 //! and other builtin functions for compiled Tish programs.
 
 #[cfg(feature = "regex")]
@@ -9,14 +9,14 @@ use std::cell::RefCell;
 use std::rc::Rc;
 use std::fmt;
 use std::sync::OnceLock;
-use tish_builtins::helpers::extract_num;
+use tishlang_builtins::helpers::extract_num;
 #[cfg(feature = "fs")]
-use tish_builtins::helpers::make_error_value;
+use tishlang_builtins::helpers::make_error_value;
 
-pub use tish_core::Value;
+pub use tishlang_core::Value;
 
-// Re-export array methods from tish_builtins
-pub use tish_builtins::array::{
+// Re-export array methods from tishlang_builtins
+pub use tishlang_builtins::array::{
     push as array_push_impl,
     pop as array_pop,
     shift as array_shift,
@@ -45,8 +45,8 @@ pub use tish_builtins::array::{
     sort_numeric_desc as array_sort_numeric_desc,
 };
 
-// Re-export string methods from tish_builtins
-pub use tish_builtins::string::{
+// Re-export string methods from tishlang_builtins
+pub use tishlang_builtins::string::{
     index_of as string_index_of_impl,
     includes as string_includes_impl,
     slice as string_slice_impl,
@@ -128,7 +128,7 @@ pub fn number_to_fixed(n: &Value, digits: &Value) -> Value {
 
 /// Operators module for compound assignment operations
 pub mod ops {
-    use tish_core::Value;
+    use tishlang_core::Value;
 
     #[inline]
     pub fn add(left: &Value, right: &Value) -> Result<Value, Box<dyn std::error::Error>> {
@@ -232,7 +232,7 @@ pub mod ops {
     }
 }
 
-use tish_builtins::globals::{
+use tishlang_builtins::globals::{
     array_is_array as builtins_array_is_array,
     boolean as builtins_boolean,
     decode_uri as builtins_decode_uri,
@@ -246,7 +246,7 @@ use tish_builtins::globals::{
     object_values as builtins_object_values,
     string_from_char_code as builtins_string_from_char_code,
 };
-use tish_core::{
+use tishlang_core::{
     json_parse as core_json_parse,
     json_stringify as core_json_stringify,
 };
@@ -291,7 +291,7 @@ fn get_log_level() -> LogLevel {
 }
 
 fn format_args(args: &[Value]) -> String {
-    tish_core::format_values_for_console(args, tish_core::use_console_colors())
+    tishlang_core::format_values_for_console(args, tishlang_core::use_console_colors())
 }
 
 pub fn console_debug(args: &[Value]) {
@@ -323,11 +323,11 @@ pub fn console_error(args: &[Value]) {
 }
 
 pub fn parse_int(args: &[Value]) -> Value {
-    tish_builtins::globals::parse_int(args)
+    tishlang_builtins::globals::parse_int(args)
 }
 
 pub fn parse_float(args: &[Value]) -> Value {
-    tish_builtins::globals::parse_float(args)
+    tishlang_builtins::globals::parse_float(args)
 }
 
 pub fn is_finite(args: &[Value]) -> Value {
@@ -350,8 +350,8 @@ pub fn encode_uri(args: &[Value]) -> Value {
     builtins_encode_uri(args)
 }
 
-// Math functions - use tish_builtins::math
-pub use tish_builtins::math::{
+// Math functions - use tishlang_builtins::math
+pub use tishlang_builtins::math::{
     abs as tish_math_abs_impl,
     sqrt as tish_math_sqrt_impl,
     floor as tish_math_floor_impl,
@@ -640,7 +640,7 @@ pub fn in_operator(key: &Value, obj: &Value) -> Value {
     Value::Bool(result)
 }
 
-// Object functions - delegate to tish_builtins::globals
+// Object functions - delegate to tishlang_builtins::globals
 pub fn object_assign(args: &[Value]) -> Value {
     builtins_object_assign(args)
 }
@@ -707,7 +707,7 @@ pub use native_promise::{await_promise, fetch_all_promise, fetch_async_promise,
 
 // RegExp Support
 #[cfg(feature = "regex")]
-pub use tish_core::{TishRegExp, RegExpFlags};
+pub use tishlang_core::{TishRegExp, RegExpFlags};
 
 #[cfg(feature = "regex")]
 pub fn regexp_new(args: &[Value]) -> Value {
@@ -753,7 +753,7 @@ pub fn regexp_exec(re: &Value, input: &Value) -> Value {
 }
 
 #[cfg(feature = "regex")]
-fn regexp_exec_impl(re: &mut tish_core::TishRegExp, input: &str) -> Value {
+fn regexp_exec_impl(re: &mut tishlang_core::TishRegExp, input: &str) -> Value {
     use std::collections::HashMap;
 
     let start = if re.flags.global || re.flags.sticky {
@@ -895,7 +895,7 @@ pub fn string_match_regex(s: &Value, regexp: &Value) -> Value {
             }
         }
         Value::String(pattern) => {
-            match tish_core::TishRegExp::new(pattern, "") {
+            match tishlang_core::TishRegExp::new(pattern, "") {
                 Ok(mut re) => regexp_exec_impl(&mut re, input),
                 Err(_) => Value::Null,
             }
@@ -987,7 +987,7 @@ pub fn string_search_regex(s: &Value, regexp: &Value) -> Value {
             }
         }
         Value::String(pattern) => {
-            match tish_core::TishRegExp::new(pattern, "") {
+            match tishlang_core::TishRegExp::new(pattern, "") {
                 Ok(re) => match re.regex.find(input) {
                     Ok(Some(m)) => {
                         let char_index = input[..m.start()].chars().count();

package/crates/tish_runtime/src/native_promise.rs

@@ -1,6 +1,6 @@
 //! Native Promise entrypoints for fetch / fetchAll.
 
-use tish_core::Value;
+use tishlang_core::Value;
 
 pub fn fetch_promise(args: Vec<Value>) -> Value {
     crate::http_fetch::fetch_promise_from_args(args)

package/crates/tish_runtime/src/promise.rs

@@ -4,7 +4,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
-use tish_core::Value;
+use tishlang_core::Value;
 
 /// Promise.resolve(value) - returns the value (immediate resolve).
 pub fn promise_resolve(args: &[Value]) -> Value {
@@ -26,7 +26,7 @@ pub fn promise_all(args: &[Value]) -> Value {
                 .iter()
                 .map(|v| {
                     if let Value::Promise(p) = v {
-                        match tish_core::TishPromise::block_until_settled(p.as_ref()) {
+                        match tishlang_core::TishPromise::block_until_settled(p.as_ref()) {
                             Ok(val) => val,
                             Err(rejection) => rejection,
                         }

package/crates/tish_runtime/src/promise_io.rs

@@ -4,7 +4,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
-use tish_core::{Value, TishPromise};
+use tishlang_core::{Value, TishPromise};
 use tokio::sync::oneshot;
 
 fn error_value(msg: String) -> Value {

package/crates/tish_runtime/src/timers.rs

@@ -6,7 +6,7 @@ use std::collections::HashMap;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
 
-use tish_core::Value;
+use tishlang_core::Value;
 
 static NEXT_ID: AtomicU64 = AtomicU64::new(1);
 

package/crates/tish_runtime/src/ws.rs

@@ -15,7 +15,7 @@ use std::time::{Duration, Instant};
 
 use futures_util::{SinkExt, StreamExt};
 use lazy_static::lazy_static;
-use tish_core::Value;
+use tishlang_core::Value;
 use tokio::sync::mpsc as tokio_mpsc;
 use tokio::runtime::Runtime;
 

package/crates/tish_runtime/tests/fetch_readable_stream.rs

@@ -6,8 +6,8 @@ use std::net::TcpListener;
 use std::thread;
 use std::time::Duration;
 
-use tish_core::Value;
-use tish_runtime::{await_promise, fetch_promise};
+use tishlang_core::Value;
+use tishlang_runtime::{await_promise, fetch_promise};
 
 fn chunked_body_server(listener: TcpListener) {
     let (mut stream, _) = listener.accept().expect("accept");

package/crates/tish_vm/Cargo.toml

@@ -1,31 +1,33 @@
 [package]
-name = "tish_vm"
+name = "tishlang_vm"
 version = "0.1.0"
 edition = "2021"
 description = "Bytecode VM for Tish"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [features]
 default = []
-regex = ["tish_core/regex"]
+regex = ["tishlang_core/regex"]
 # For wasm32 target: use web_sys console for output
 wasm = ["dep:wasm-bindgen"]
 # Built-in modules: fs, http, process (for bytecode LoadNativeExport)
-fs = ["tish_runtime/fs"]
-process = ["tish_runtime/process"]
-http = ["tish_runtime/http"]
-ws = ["tish_runtime/ws"]
+fs = ["tishlang_runtime/fs"]
+process = ["tishlang_runtime/process"]
+http = ["tishlang_runtime/http"]
+ws = ["tishlang_runtime/ws"]
 
 [dependencies]
-tish_ast = { path = "../tish_ast" }
-tish_builtins = { path = "../tish_builtins" }
-tish_bytecode = { path = "../tish_bytecode" }
-tish_core = { path = "../tish_core" }
-tish_runtime = { path = "../tish_runtime", optional = true }
+tishlang_ast = { path = "../tish_ast" }
+tishlang_builtins = { path = "../tish_builtins" }
+tishlang_bytecode = { path = "../tish_bytecode" }
+tishlang_core = { path = "../tish_core" }
+tishlang_runtime = { path = "../tish_runtime", optional = true }
 rand = "0.10"
 wasm-bindgen = { version = "0.2", optional = true }
 
 [dev-dependencies]
-tish_parser = { path = "../tish_parser" }
+tishlang_parser = { path = "../tish_parser" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.4", features = ["wasm_js"] }

package/crates/tish_vm/src/lib.rs

@@ -32,8 +32,8 @@ switch (k) {
         fn f(a, b, ...rest) { return rest.length; }
         console.log(f(1,2,3,4));
 "#;
-        let program = tish_parser::parse(src).expect("parse");
-        let chunk = tish_bytecode::compile(&program).expect("compile");
+        let program = tishlang_parser::parse(src).expect("parse");
+        let chunk = tishlang_bytecode::compile(&program).expect("compile");
         let _ = run(&chunk).expect("run");
     }
 }