@tishlang/tish 1.0.13 → 1.0.15

package/crates/js_to_tish/Cargo.toml

@@ -1,9 +1,11 @@
 [package]
-name = "js_to_tish"
+name = "tishlang_js_to_tish"
 version = "0.1.0"
 edition = "2021"
 description = "Vanilla JavaScript to Tish AST converter"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [dependencies]
 oxc = { version = "0.121", features = ["semantic"] }
-tish_ast = { path = "../tish_ast" }
+tishlang_ast = { path = "../tish_ast" }

package/crates/js_to_tish/src/span_util.rs

@@ -1,7 +1,7 @@
 //! Span conversion from OXC offsets to Tish (line, col).
 
 use oxc::span::GetSpan;
-use tish_ast::Span;
+use tishlang_ast::Span;
 
 /// Convert OXC span (byte start/end) to Tish Span (line, col).
 /// Uses source text to compute line/column from offsets.

package/crates/js_to_tish/src/transform/expr.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use oxc::ast::ast::Expression as OxcExpr;
 use oxc::semantic::Semantic;
-use tish_ast::{
+use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CompoundOp, DestructPattern, Expr, Literal, LogicalAssignOp,
     MemberProp, ObjectProp, TypedParam,
 };
@@ -155,7 +155,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                 ArrowBody::Expr(Box::new(convert_expr(e, ctx)?))
             } else {
                 let stmts = super::stmt::convert_statements(&arrow.body.statements, ctx.0, ctx.1)?;
-                ArrowBody::Block(Box::new(tish_ast::Statement::Block {
+                ArrowBody::Block(Box::new(tishlang_ast::Statement::Block {
                     statements: stmts,
                     span: span_util::oxc_span_to_tish(ctx.1, &*arrow.body),
                 }))
@@ -205,7 +205,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
             let body = match &f.body {
                 Some(fb) => {
                     let stmts = super::stmt::convert_statements(&fb.statements, ctx.0, ctx.1)?;
-                    ArrowBody::Block(Box::new(tish_ast::Statement::Block {
+                    ArrowBody::Block(Box::new(tishlang_ast::Statement::Block {
                         statements: stmts,
                         span: span_util::oxc_span_to_tish(ctx.1, fb.as_ref()),
                     }))
@@ -233,7 +233,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
 fn convert_chain_element(
     ce: &oxc::ast::ast::ChainElement<'_>,
     ctx: &Ctx<'_>,
-    span: tish_ast::Span,
+    span: tishlang_ast::Span,
 ) -> Result<Expr, ConvertError> {
     match ce {
         oxc::ast::ast::ChainElement::StaticMemberExpression(m) => {
@@ -273,15 +273,15 @@ fn convert_chain_element(
 fn convert_call_arg(
     arg: &oxc::ast::ast::Argument<'_>,
     ctx: &Ctx<'_>,
-) -> Result<tish_ast::CallArg, ConvertError> {
+) -> Result<tishlang_ast::CallArg, ConvertError> {
     if arg.is_spread() {
         if let oxc::ast::ast::Argument::SpreadElement(s) = arg {
-            Ok(tish_ast::CallArg::Spread(convert_expr(&s.argument, ctx)?))
+            Ok(tishlang_ast::CallArg::Spread(convert_expr(&s.argument, ctx)?))
         } else {
             unreachable!()
         }
     } else if let Some(e) = arg.as_expression() {
-        Ok(tish_ast::CallArg::Expr(convert_expr(e, ctx)?))
+        Ok(tishlang_ast::CallArg::Expr(convert_expr(e, ctx)?))
     } else {
         Err(ConvertError::new(ConvertErrorKind::Unsupported {
             what: "call argument".into(),
@@ -340,7 +340,7 @@ fn convert_object_prop(
 fn convert_assignment(
     a: &oxc::ast::ast::AssignmentExpression<'_>,
     ctx: &Ctx<'_>,
-    span: tish_ast::Span,
+    span: tishlang_ast::Span,
 ) -> Result<Expr, ConvertError> {
     let (left, right) = (&a.left, &a.right);
     if let Some(oxc::ast::ast::SimpleAssignmentTarget::AssignmentTargetIdentifier(id)) =
@@ -435,7 +435,7 @@ fn convert_assignment(
 fn convert_update_expr(
     u: &oxc::ast::ast::UpdateExpression<'_>,
     _ctx: &Ctx<'_>,
-    span: tish_ast::Span,
+    span: tishlang_ast::Span,
 ) -> Result<Expr, ConvertError> {
     let name: Arc<str> = match &u.argument {
         oxc::ast::ast::SimpleAssignmentTarget::AssignmentTargetIdentifier(id) => {
@@ -498,13 +498,13 @@ fn convert_bin_op(
 
 fn convert_unary_op(
     op: &oxc::ast::ast::UnaryOperator,
-) -> Result<tish_ast::UnaryOp, ConvertError> {
+) -> Result<tishlang_ast::UnaryOp, ConvertError> {
     Ok(match op {
-        oxc::ast::ast::UnaryOperator::LogicalNot => tish_ast::UnaryOp::Not,
-        oxc::ast::ast::UnaryOperator::UnaryNegation => tish_ast::UnaryOp::Neg,
-        oxc::ast::ast::UnaryOperator::UnaryPlus => tish_ast::UnaryOp::Pos,
-        oxc::ast::ast::UnaryOperator::BitwiseNot => tish_ast::UnaryOp::BitNot,
-        oxc::ast::ast::UnaryOperator::Void => tish_ast::UnaryOp::Void,
+        oxc::ast::ast::UnaryOperator::LogicalNot => tishlang_ast::UnaryOp::Not,
+        oxc::ast::ast::UnaryOperator::UnaryNegation => tishlang_ast::UnaryOp::Neg,
+        oxc::ast::ast::UnaryOperator::UnaryPlus => tishlang_ast::UnaryOp::Pos,
+        oxc::ast::ast::UnaryOperator::BitwiseNot => tishlang_ast::UnaryOp::BitNot,
+        oxc::ast::ast::UnaryOperator::Void => tishlang_ast::UnaryOp::Void,
         _ => {
             return Err(ConvertError::new(ConvertErrorKind::Unsupported {
                 what: format!("unary operator: {op:?}"),

package/crates/js_to_tish/src/transform/stmt.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use oxc::ast::ast::Statement as OxcStmt;
 use oxc::semantic::Semantic;
-use tish_ast::{Statement, Span};
+use tishlang_ast::{Statement, Span};
 
 use super::expr;
 use crate::error::{ConvertError, ConvertErrorKind};
@@ -406,18 +406,18 @@ fn convert_import(
                     } else {
                         Some(Arc::from(local_name))
                     };
-                    specifiers.push(tish_ast::ImportSpecifier::Named {
+                    specifiers.push(tishlang_ast::ImportSpecifier::Named {
                         name: Arc::from(imported_name),
                         alias,
                     });
                 }
                 oxc::ast::ast::ImportDeclarationSpecifier::ImportDefaultSpecifier(ds) => {
-                    specifiers.push(tish_ast::ImportSpecifier::Default(Arc::from(
+                    specifiers.push(tishlang_ast::ImportSpecifier::Default(Arc::from(
                         ds.local.name.as_str(),
                     )));
                 }
                 oxc::ast::ast::ImportDeclarationSpecifier::ImportNamespaceSpecifier(ns) => {
-                    specifiers.push(tish_ast::ImportSpecifier::Namespace(Arc::from(
+                    specifiers.push(tishlang_ast::ImportSpecifier::Namespace(Arc::from(
                         ns.local.name.as_str(),
                     )));
                 }
@@ -438,10 +438,10 @@ fn convert_export_default(
 ) -> Result<Statement, ConvertError> {
     let declaration = if let Some(expr) = e.declaration.as_expression() {
         let expr = expr::convert_expr(expr, ctx)?;
-        tish_ast::ExportDeclaration::Default(expr)
+        tishlang_ast::ExportDeclaration::Default(expr)
     } else if let oxc::ast::ast::ExportDefaultDeclarationKind::FunctionDeclaration(f) = &e.declaration {
         let stmt = convert_function_decl(f.as_ref(), ctx, span_util::stub_span())?;
-        tish_ast::ExportDeclaration::Named(Box::new(stmt))
+        tishlang_ast::ExportDeclaration::Named(Box::new(stmt))
     } else {
         return Err(ConvertError::new(ConvertErrorKind::Unsupported {
             what: "export default (this form)".into(),
@@ -462,7 +462,7 @@ fn convert_export_named(
     if let Some(decl) = &e.declaration {
         let stmt = convert_declaration(decl, ctx)?;
         Ok(Statement::Export {
-            declaration: Box::new(tish_ast::ExportDeclaration::Named(Box::new(stmt))),
+            declaration: Box::new(tishlang_ast::ExportDeclaration::Named(Box::new(stmt))),
             span,
         })
     } else {

package/crates/js_to_tish/src/transform.rs

@@ -7,7 +7,7 @@ use oxc::allocator::Allocator;
 use oxc::parser::Parser;
 use oxc::semantic::SemanticBuilder;
 use oxc::span::SourceType;
-use tish_ast::Program;
+use tishlang_ast::Program;
 
 use crate::error::{ConvertError, ConvertErrorKind};
 use crate::transform::stmt::convert_statements;

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "tish"
-version = "1.0.13"
+name = "tishlang"
+version = "1.0.15"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }
@@ -16,28 +16,28 @@ default = []
 # Full: all capabilities enabled (for development/trusted environments)
 full = ["http", "fs", "process", "regex", "ws"]
 # Individual capability flags
-http = ["tish_eval/http", "tish_runtime/http", "tish_compile/http", "tish_vm/http"]
-fs = ["tish_eval/fs", "tish_runtime/fs", "tish_compile/fs", "tish_vm/fs"]
-process = ["tish_eval/process", "tish_runtime/process", "tish_compile/process", "tish_vm/process"]
-regex = ["tish_eval/regex", "tish_runtime/regex", "tish_compile/regex", "tish_vm/regex"]
-ws = ["tish_eval/ws", "tish_runtime/ws", "tish_compile/ws", "tish_vm/ws"]
+http = ["tishlang_eval/http", "tishlang_runtime/http", "tishlang_compile/http", "tishlang_vm/http"]
+fs = ["tishlang_eval/fs", "tishlang_runtime/fs", "tishlang_compile/fs", "tishlang_vm/fs"]
+process = ["tishlang_eval/process", "tishlang_runtime/process", "tishlang_compile/process", "tishlang_vm/process"]
+regex = ["tishlang_eval/regex", "tishlang_runtime/regex", "tishlang_compile/regex", "tishlang_vm/regex"]
+ws = ["tishlang_eval/ws", "tishlang_runtime/ws", "tishlang_compile/ws", "tishlang_vm/ws"]
 [dependencies]
 rustyline = { version = "17", features = ["with-file-history"] }
-tish_lexer = { path = "../tish_lexer" }
-tish_ast = { path = "../tish_ast" }
-tish_parser = { path = "../tish_parser" }
-tish_eval = { path = "../tish_eval" }
-tish_compile = { path = "../tish_compile" }
-tish_compile_js = { path = "../tish_compile_js" }
-tish_bytecode = { path = "../tish_bytecode" }
-tish_opt = { path = "../tish_opt" }
-tish_vm = { path = "../tish_vm" }
-tish_native = { path = "../tish_native" }
-tish_llvm = { path = "../tish_llvm" }
-tish_wasm = { path = "../tish_wasm" }
-tish_runtime = { path = "../tish_runtime" }
-tish_core = { path = "../tish_core" }
-js_to_tish = { path = "../js_to_tish" }
+tishlang_lexer = { path = "../tish_lexer" }
+tishlang_ast = { path = "../tish_ast" }
+tishlang_parser = { path = "../tish_parser" }
+tishlang_eval = { path = "../tish_eval" }
+tishlang_compile = { path = "../tish_compile" }
+tishlang_compile_js = { path = "../tish_compile_js" }
+tishlang_bytecode = { path = "../tish_bytecode" }
+tishlang_opt = { path = "../tish_opt" }
+tishlang_vm = { path = "../tish_vm" }
+tishlang_native = { path = "../tish_native" }
+tishlang_llvm = { path = "../tish_llvm" }
+tishlang_wasm = { path = "../tish_wasm" }
+tishlang_runtime = { path = "../tish_runtime" }
+tishlang_core = { path = "../tish_core" }
+tishlang_js_to_tish = { path = "../js_to_tish" }
 clap = { version = "4.6.0", features = ["derive"] }
 
 [dev-dependencies]

package/crates/tish/src/main.rs

@@ -117,42 +117,42 @@ fn run_file(path: &str, backend: &str, _features: &[String], no_optimize: bool)
     });
 
     let program = if path.extension().map(|e| e == "js") == Some(true) {
-        let prog = js_to_tish::convert(&fs::read_to_string(&path).map_err(|e| format!("{}", e))?)
+        let prog = tishlang_js_to_tish::convert(&fs::read_to_string(&path).map_err(|e| format!("{}", e))?)
             .map_err(|e| format!("{}", e))?;
         if no_optimize {
             prog
         } else {
-            tish_opt::optimize(&prog)
+            tishlang_opt::optimize(&prog)
         }
     } else {
-        let modules = tish_compile::resolve_project(&path, project_root)?;
-        tish_compile::detect_cycles(&modules)?;
-        let prog = tish_compile::merge_modules(modules)?;
+        let modules = tishlang_compile::resolve_project(&path, project_root)?;
+        tishlang_compile::detect_cycles(&modules)?;
+        let prog = tishlang_compile::merge_modules(modules)?;
         if no_optimize {
             prog
         } else {
-            tish_opt::optimize(&prog)
+            tishlang_opt::optimize(&prog)
         }
     };
 
     if backend == "interp" {
-        let mut eval = tish_eval::Evaluator::new();
+        let mut eval = tishlang_eval::Evaluator::new();
         let value = eval.eval_program(&program)?;
-        if !matches!(value, tish_eval::Value::Null) {
-            println!("{}", tish_eval::format_value_for_console(&value, tish_core::use_console_colors()));
+        if !matches!(value, tishlang_eval::Value::Null) {
+            println!("{}", tishlang_eval::format_value_for_console(&value, tishlang_core::use_console_colors()));
         }
         return Ok(());
     }
 
     // VM backend (bytecode) - supports native imports when built with fs/http/process features
     let chunk = if no_optimize {
-        tish_bytecode::compile_unoptimized(&program).map_err(|e| e.to_string())?
+        tishlang_bytecode::compile_unoptimized(&program).map_err(|e| e.to_string())?
     } else {
-        tish_bytecode::compile(&program).map_err(|e| e.to_string())?
+        tishlang_bytecode::compile(&program).map_err(|e| e.to_string())?
     };
-    let value = tish_vm::run(&chunk)?;
-    if !matches!(value, tish_core::Value::Null) {
-        println!("{}", tish_core::format_value_styled(&value, tish_core::use_console_colors()));
+    let value = tishlang_vm::run(&chunk)?;
+    if !matches!(value, tishlang_core::Value::Null) {
+        println!("{}", tishlang_core::format_value_styled(&value, tishlang_core::use_console_colors()));
     }
     Ok(())
 }
@@ -162,7 +162,7 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
     let mut buffer = String::new();
 
     if backend == "interp" {
-        let mut eval = tish_eval::Evaluator::new();
+        let mut eval = tishlang_eval::Evaluator::new();
         let mut multiline = String::new();
         loop {
             let prompt = repl_prompt(multiline.is_empty());
@@ -171,7 +171,7 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
             buffer.clear();
             if io::stdin().read_line(&mut buffer).map_err(|e| e.to_string())? == 0 {
                 if !multiline.is_empty() {
-                    let _ = tish_parser::parse(multiline.trim());
+                    let _ = tishlang_parser::parse(multiline.trim());
                 }
                 break;
             }
@@ -185,12 +185,12 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
                 multiline.push('\n');
                 multiline.push_str(line);
             }
-            match tish_parser::parse(multiline.trim()) {
+            match tishlang_parser::parse(multiline.trim()) {
                 Ok(program) => {
                     match eval.eval_program(&program) {
                         Ok(v) => {
-                            if !matches!(v, tish_eval::Value::Null) {
-                                println!("{}", tish_eval::format_value_for_console(&v, tish_core::use_console_colors()));
+                            if !matches!(v, tishlang_eval::Value::Null) {
+                                println!("{}", tishlang_eval::format_value_for_console(&v, tishlang_core::use_console_colors()));
                             }
                         }
                         Err(e) => eprintln!("{}", e),
@@ -214,7 +214,7 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
     if !std::io::stdin().is_terminal() {
         eprintln!("Note: Tab completion and grey preview require an interactive terminal (TTY).");
     }
-    let vm = Rc::new(RefCell::new(tish_vm::Vm::new()));
+    let vm = Rc::new(RefCell::new(tishlang_vm::Vm::new()));
     let completer = repl_completion::ReplCompleter {
         vm: Rc::clone(&vm),
         no_optimize,
@@ -246,12 +246,12 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
                 if buffer.is_empty() {
                     break;
                 }
-                match tish_parser::parse(buffer.trim()) {
+                match tishlang_parser::parse(buffer.trim()) {
                     Ok(program) => {
                         let compile_fn = if no_optimize {
-                            tish_bytecode::compile_for_repl_unoptimized
+                            tishlang_bytecode::compile_for_repl_unoptimized
                         } else {
-                            tish_bytecode::compile_for_repl
+                            tishlang_bytecode::compile_for_repl
                         };
                         if let Ok(chunk) = compile_fn(&program) {
                             let _ = vm.borrow_mut().run(&chunk);
@@ -277,19 +277,19 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
             buffer.push('\n');
             buffer.push_str(line);
         }
-        match tish_parser::parse(buffer.trim()) {
+        match tishlang_parser::parse(buffer.trim()) {
             Ok(program) => {
                 let compile_fn = if no_optimize {
-                    tish_bytecode::compile_for_repl_unoptimized
+                    tishlang_bytecode::compile_for_repl_unoptimized
                 } else {
-                    tish_bytecode::compile_for_repl
+                    tishlang_bytecode::compile_for_repl
                 };
                 match compile_fn(&program) {
                     Ok(chunk) => {
                         match vm.borrow_mut().run(&chunk) {
                             Ok(v) => {
-                                if !matches!(v, tish_core::Value::Null) {
-                                    println!("{}", tish_core::format_value_styled(&v, tish_core::use_console_colors()));
+                                if !matches!(v, tishlang_core::Value::Null) {
+                                    println!("{}", tishlang_core::format_value_styled(&v, tishlang_core::use_console_colors()));
                                 }
                             }
                             Err(e) => eprintln!("{}", e),
@@ -319,7 +319,7 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
 
 /// REPL prompt with green caret when stdout is a TTY (platform-style).
 fn repl_prompt(primary: bool) -> String {
-    if tish_core::use_console_colors() {
+    if tishlang_core::use_console_colors() {
         if primary {
             "\x1b[32m> \x1b[0m".to_string()
         } else {
@@ -339,15 +339,15 @@ fn tish_history_path() -> Option<PathBuf> {
     home.map(|h| PathBuf::from(h).join(".tish_history"))
 }
 
-fn parse_jsx_mode(s: &str) -> Result<tish_compile_js::JsxMode, String> {
+fn parse_jsx_mode(s: &str) -> Result<tishlang_compile_js::JsxMode, String> {
     match s {
         "legacy" => Err(
             "--jsx legacy was removed. Use --jsx lattish (default) with lattish merged into your \
              bundle, or --jsx vdom with Lattish's createRoot."
                 .to_string(),
         ),
-        "vdom" => Ok(tish_compile_js::JsxMode::Vdom),
-        "lattish" => Ok(tish_compile_js::JsxMode::LattishH),
+        "vdom" => Ok(tishlang_compile_js::JsxMode::Vdom),
+        "lattish" => Ok(tishlang_compile_js::JsxMode::LattishH),
         other => Err(format!(
             "Unknown --jsx {:?}: use lattish (default) or vdom.",
             other
@@ -375,20 +375,20 @@ fn compile_to_js(
             "export fn __TishJsxRoot() {{\n  return (\n{}\n  )\n}}",
             source.trim()
         );
-        let program = tish_parser::parse(&wrapped)
+        let program = tishlang_parser::parse(&wrapped)
             .map_err(|e| format!("JSX wrapper parse: {}", e))?;
         let p = if optimize {
-            tish_opt::optimize(&program)
+            tishlang_opt::optimize(&program)
         } else {
             program
         };
-        tish_compile_js::compile_with_jsx(&p, optimize, jsx_mode).map_err(|e| format!("{}", e))?
+        tishlang_compile_js::compile_with_jsx(&p, optimize, jsx_mode).map_err(|e| format!("{}", e))?
     } else if input_path.extension().map(|e| e == "js") == Some(true) {
         let source = fs::read_to_string(input_path).map_err(|e| format!("{}", e))?;
-        let program = js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        tish_compile_js::compile_with_jsx(&program, optimize, jsx_mode).map_err(|e| format!("{}", e))?
+        let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
+        tishlang_compile_js::compile_with_jsx(&program, optimize, jsx_mode).map_err(|e| format!("{}", e))?
     } else {
-        tish_compile_js::compile_project_with_jsx(input_path, project_root, optimize, jsx_mode)
+        tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize, jsx_mode)
             .map_err(|e| format!("{}", e))?
     };
 
@@ -432,8 +432,8 @@ fn compile_file(
 
     if target == "wasm" && is_js {
         let source = fs::read_to_string(&input_path).map_err(|e| format!("{}", e))?;
-        let program = js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        return tish_wasm::compile_program_to_wasm(&program, Path::new(output_path), optimize)
+        let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
+        return tishlang_wasm::compile_program_to_wasm(&program, Path::new(output_path), optimize)
             .map_err(|e| format!("{}", e));
     }
 
@@ -445,7 +445,7 @@ fn compile_file(
                 Some(p)
             }
         });
-        return tish_wasm::compile_to_wasm(&input_path, project_root, Path::new(output_path), optimize)
+        return tishlang_wasm::compile_to_wasm(&input_path, project_root, Path::new(output_path), optimize)
             .map_err(|e| e.to_string());
     }
 
@@ -457,7 +457,7 @@ fn compile_file(
                 Some(p)
             }
         });
-        return tish_wasm::compile_to_wasi(&input_path, project_root, Path::new(output_path), optimize)
+        return tishlang_wasm::compile_to_wasi(&input_path, project_root, Path::new(output_path), optimize)
             .map_err(|e| e.to_string());
     }
 
@@ -495,8 +495,8 @@ fn compile_file(
 
     if is_js {
         let source = fs::read_to_string(&input_path).map_err(|e| format!("{}", e))?;
-        let program = js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        tish_native::compile_program_to_native(
+        let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
+        tishlang_native::compile_program_to_native(
             &program,
             project_root,
             Path::new(output_path),
@@ -506,7 +506,7 @@ fn compile_file(
         )
         .map_err(|e| e.to_string())?;
     } else {
-        tish_native::compile_to_native(
+        tishlang_native::compile_to_native(
             &input_path,
             project_root,
             Path::new(output_path),
@@ -580,7 +580,7 @@ mod cli_tests {
 fn dump_ast(path: &str) -> Result<(), String> {
     let source =
         fs::read_to_string(path).map_err(|e| format!("Cannot read {}: {}", path, e))?;
-    let program = tish_parser::parse(&source)?;
+    let program = tishlang_parser::parse(&source)?;
     println!("{:#?}", program);
     Ok(())
 }

package/crates/tish/src/repl_completion.rs

@@ -12,9 +12,9 @@ use rustyline::validate::Validator;
 use rustyline::Context;
 use rustyline::Helper;
 
-use tish_bytecode::{compile_for_repl, compile_for_repl_unoptimized};
-use tish_parser;
-use tish_vm::Vm;
+use tishlang_bytecode::{compile_for_repl, compile_for_repl_unoptimized};
+use tishlang_parser;
+use tishlang_vm::Vm;
 
 /// Tish keywords for bare-word completion (Python-style).
 const KEYWORDS: &[&str] = &[
@@ -79,7 +79,7 @@ impl ReplCompleter {
         }
         let member_prefix = line_before_cursor[last_dot + 1..].trim();
 
-        let program = tish_parser::parse(prefix_expr).ok()?;
+        let program = tishlang_parser::parse(prefix_expr).ok()?;
         let compile_fn = if self.no_optimize {
             compile_for_repl_unoptimized
         } else {